tx · 7NXR58diaiVszBSE7KAcn8TYT2ai7odPTAt3zd4BFT2m

3MsXpzisJAwnzUr7XrEoW1BZo4U6rw4tsYK:  -0.10000000 Waves

2022.10.11 11:56 [2267471] smart account 3MsXpzisJAwnzUr7XrEoW1BZo4U6rw4tsYK > SELF 0.00000000 Waves

{ "type": 13, "id": "7NXR58diaiVszBSE7KAcn8TYT2ai7odPTAt3zd4BFT2m", "fee": 10000000, "feeAssetId": null, "timestamp": 1665478613752, "version": 2, "chainId": 84, "sender": "3MsXpzisJAwnzUr7XrEoW1BZo4U6rw4tsYK", "senderPublicKey": "FFdBua5rzzMkZebvsvmN7sAdU7XhFK8QNJ3hiwwxAYRA", "proofs": [ "32bmQ6SvCLv9qUWcmPomVBxZugkKgZugiwQDU9RsuyEGNTwRSpzcSWVQVxoaxHDTnYbMNKzcUpBxVcErUqixt8is" ], "script": "base64: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", "height": 2267471, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: 4G6GZo7sucHyRPB4SLjmriLKDCARZMbA3eZLdqa1QdyS Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let keyShareTokensLocked = "_total_share_tokens_locked"
5+
6+let kShareLimit = "share_limit_on_first_harvest"
7+
8+let keyActive = "active"
9+
10+let keyCause = "shutdown_cause"
11+
12+let keyRewardPoolFractionCurrent = "_current_pool_fraction_reward"
13+
14+let keyRewardPoolFractionPrevious = "_previous_pool_fraction_reward"
15+
16+let keyHeightPoolFraction = "_pool_reward_update_height"
17+
18+let keyTotalRewardPerBlockCurrent = "total_reward_per_block_current"
19+
20+let keyTotalRewardPerBlockPrevious = "total_reward_per_block_previous"
21+
22+let keyRewardUpdateHeight = "reward_update_height"
23+
24+let keyLastInterest = "_last_interest"
25+
26+let keyLastInterestHeight = "_last_interest_height"
27+
28+let keyUserShareTokensLocked = "_share_tokens_locked"
29+
30+let keyUserLastInterest = "_last_interest"
31+
32+let keySWOPid = "SWOP_id"
33+
34+let keyUserSWOPClaimedAmount = "_SWOP_claimed_amount"
35+
36+let keyUserSWOPLastClaimedAmount = "_SWOP_last_claimed_amount"
37+
38+let keyAvailableSWOP = "_available_SWOP"
39+
40+let keyFarmingStartHeight = "farming_start_height"
41+
42+let keyAPY = "apy"
43+
44+let kPreviousTotalVoteSWOP = "previous_total_vote_SWOP"
45+
46+let keySwopYearEmission = "swop_year_emission"
47+
48+let keyBalancecpmmA = "A_asset_balance"
49+
50+let keyBalancecpmmB = "B_asset_balance"
51+
52+let kHarvestPoolActiveVoteStrucVoting = "_harvest_pool_activeVote_struc"
53+
54+let kHarvestUserPoolActiveVoteStrucVoting = "_harvest_user_pool_activeVote_struc"
55+
56+let keyLimitShareFirstHarvest = "share_limit_on_first_harvest"
57+
58+let keyAssetIdA = "A_asset_id"
59+
60+let keyAssetIdB = "B_asset_id"
61+
62+let keyFirstHarvestHeight = "first_harvest_height"
63+
64+let keyfirstHarvestCpmm = "first_harvest"
65+
66+let keyTempPrevSum = "sum_reward_previous"
67+
68+let keyTempCurSum = "sum_reward_current"
69+
70+let oneWeekInBlock = 10106
71+
72+let totalVoteShare = 10000000000
73+
74+let scaleValue1 = 10
75+
76+let scaleValue3 = 1000
77+
78+let scaleValue5 = 100000
79+
80+let scaleValue6 = 1000000
81+
82+let scaleValue8 = 100000000
83+
84+let scaleValue11 = 100000000000
85+
86+let kAdminPubKey1 = "admin_pub_1"
87+
88+let kAdminPubKey2 = "admin_pub_2"
89+
90+let kAdminPubKey3 = "admin_pub_3"
91+
92+let kAdminInvokePubKey = "admin_invoke_pub"
93+
94+let kMoneyBoxAddress = "money_box_address"
95+
96+let kVotingAddress = "voting_address"
97+
98+let kGovAddress = "governance_address"
99+
100+let kLPFarmingAddress = "lp_farming"
101+
102+let oracle = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
103+
104+func getBase58FromOracle (key) = match getString(oracle, key) {
105+ case string: String =>
106+ fromBase58String(string)
107+ case nothing =>
108+ throw((key + "is empty"))
109+}
110+
111+
112+let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
113+
114+let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
115+
116+let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
117+
118+let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
119+
120+let votingAddress = Address(getBase58FromOracle(kVotingAddress))
121+
122+let govAddress = Address(getBase58FromOracle(kGovAddress))
123+
124+let adminInvokePubKey = getBase58FromOracle(kAdminInvokePubKey)
125+
126+let lpFarmingAddress = Address(getBase58FromOracle(kLPFarmingAddress))
127+
128+func strAssetIdA (pool) = getStringValue(pool, keyAssetIdA)
129+
130+
131+func strAssetIdB (pool) = getStringValue(pool, keyAssetIdB)
132+
133+
134+func assetIdA (pool) = if ((strAssetIdA(pool) == "WAVES"))
135+ then unit
136+ else fromBase58String(strAssetIdA(pool))
137+
138+
139+func assetIdB (pool) = if ((strAssetIdB(pool) == "WAVES"))
140+ then unit
141+ else fromBase58String(strAssetIdB(pool))
142+
143+
144+let kBasePeriod = "base_period"
145+
146+let kPeriodLength = "period_length"
147+
148+let kStartHeight = "start_height"
149+
150+let kFirstHarvestHeight = "first_harvest_height"
151+
152+let kDurationFullVotePower = "duration_full_vote_power"
153+
154+let kMinVotePower = "min_vote_power"
155+
156+let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
157+
158+let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
159+
160+let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
161+
162+let durationFullVotePower = valueOrErrorMessage(getInteger(votingAddress, kDurationFullVotePower), "Empty kDurationFullVotePower")
163+
164+let minVotePower = valueOrErrorMessage(getInteger(votingAddress, kMinVotePower), "Empty kMinVotePower")
165+
166+let isActive = getBooleanValue(this, keyActive)
167+
168+let currPeriod = (basePeriod + ((height - startHeight) / periodLength))
169+
170+func getLimitToken (pool) = valueOrElse(getIntegerValue(pool, keyLimitShareFirstHarvest), 0)
171+
172+
173+let APY = getIntegerValue(this, keyAPY)
174+
175+let SwopYearEmission = getIntegerValue(this, keySwopYearEmission)
176+
177+func assetNameA (pool) = match assetIdA(pool) {
178+ case id: ByteVector =>
179+ value(assetInfo(id)).name
180+ case waves: Unit =>
181+ "WAVES"
182+ case _ =>
183+ throw("Match error")
184+}
185+
186+
187+func assetNameB (pool) = match assetIdB(pool) {
188+ case id: ByteVector =>
189+ value(assetInfo(id)).name
190+ case waves: Unit =>
191+ "WAVES"
192+ case _ =>
193+ throw("Match error")
194+}
195+
196+
197+let SWOP = fromBase58String(getStringValue(this, keySWOPid))
198+
199+func isFirstHarvest (pool) = valueOrElse(getBoolean(pool, keyfirstHarvestCpmm), false)
200+
201+
202+func getHeightFirstHarvest (pool) = valueOrElse(getInteger(pool, keyFirstHarvestHeight), 0)
203+
204+
205+func getBalanceA (pool) = valueOrErrorMessage(getInteger(pool, keyBalancecpmmA), ("No data on the key: " + keyBalancecpmmA))
206+
207+
208+func getBalanceB (pool) = valueOrErrorMessage(getInteger(pool, keyBalancecpmmB), ("No data on the key: " + keyBalancecpmmB))
209+
210+
211+func getShareLimitToken (pool) = valueOrErrorMessage(getInteger(pool, kShareLimit), ("No data on the key: " + kShareLimit))
212+
213+
214+func getTotalShareTokenLocked (pool) = valueOrErrorMessage(getInteger(this, (pool + keyShareTokensLocked)), (("No data on the key: " + pool) + keyShareTokensLocked))
215+
216+
217+func getShareAssetId (pool) = fromBase58String(getStringValue(value(addressFromString(pool)), "share_asset_id"))
218+
219+
220+func accountBalance (assetId) = match assetId {
221+ case id: ByteVector =>
222+ assetBalance(this, id)
223+ case waves: Unit =>
224+ wavesBalance(this).available
225+ case _ =>
226+ throw("Match error")
227+}
228+
229+
230+func getAssetInfo (assetId) = match assetId {
231+ case id: ByteVector =>
232+ let stringId = toBase58String(id)
233+ let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
234+ $Tuple3(stringId, info.name, info.decimals)
235+ case waves: Unit =>
236+ $Tuple3("WAVES", "WAVES", 8)
237+ case _ =>
238+ throw("Match error")
239+}
240+
241+
242+func calcScaleValue (assetId1,assetId2) = {
243+ let assetId1Decimals = value(assetInfo(assetId1)).decimals
244+ let assetId2Decimals = value(assetInfo(assetId2)).decimals
245+ let scaleDigits = ((assetId2Decimals - assetId1Decimals) + 8)
246+ pow(10, 0, scaleDigits, 0, 0, DOWN)
247+ }
248+
249+
250+func userAvailableSWOP (pool,user) = valueOrElse(getInteger(this, (((pool + "_") + toString(user)) + keyAvailableSWOP)), 0)
251+
252+
253+func rewardInfo (pool) = {
254+ let totalRewardPerBlockCurrent = valueOrErrorMessage(getInteger(govAddress, keyTotalRewardPerBlockCurrent), ((("No data on the key: " + keyTotalRewardPerBlockCurrent) + " at address ") + toString(govAddress)))
255+ let totalRewardPerBlockPrevious = valueOrErrorMessage(getInteger(govAddress, keyTotalRewardPerBlockPrevious), ((("No data on the key: " + keyTotalRewardPerBlockPrevious) + " at address ") + toString(govAddress)))
256+ let rewardPoolFractionCurrent = valueOrErrorMessage(getInteger(govAddress, (pool + keyRewardPoolFractionCurrent)), (((("No data on the key: " + pool) + keyRewardPoolFractionCurrent) + " at address ") + toString(govAddress)))
257+ let rewardUpdateHeight = valueOrErrorMessage(getInteger(govAddress, keyRewardUpdateHeight), ((("No data on the key: " + keyRewardUpdateHeight) + " at address ") + toString(govAddress)))
258+ let poolRewardUpdateHeight = valueOrElse(getInteger(govAddress, (pool + keyHeightPoolFraction)), 0)
259+ let rewardPoolFractionPrevious = valueOrErrorMessage(getInteger(govAddress, (pool + keyRewardPoolFractionPrevious)), (((("No data on the key: " + pool) + keyRewardPoolFractionPrevious) + " at address ") + toString(govAddress)))
260+ let rewardPoolCurrent = fraction(totalRewardPerBlockCurrent, rewardPoolFractionCurrent, totalVoteShare)
261+ let rewardPoolPrevious = fraction(totalRewardPerBlockPrevious, rewardPoolFractionPrevious, totalVoteShare)
262+ if (if ((rewardPoolCurrent > totalRewardPerBlockCurrent))
263+ then true
264+ else (rewardPoolPrevious > totalRewardPerBlockPrevious))
265+ then throw("rewardPoolCurrent > totalRewardPerBlockCurrent or rewardPoolPrevious > totalRewardPerBlockPrevious")
266+ else $Tuple4(rewardPoolCurrent, rewardUpdateHeight, rewardPoolPrevious, poolRewardUpdateHeight)
267+ }
268+
269+
270+func getLastInterestInfo (pool) = {
271+ let lastInterest = valueOrErrorMessage(getInteger(this, (pool + keyLastInterest)), (("No data on the key: " + pool) + keyLastInterest))
272+ let lastInterestHeight = valueOrElse(getInteger(this, (pool + keyLastInterestHeight)), height)
273+ $Tuple2(lastInterestHeight, lastInterest)
274+ }
275+
276+
277+func getUserInterestInfo (pool,userAddress) = {
278+ let userLastInterest = getInteger(this, (((pool + "_") + toString(userAddress)) + keyUserLastInterest))
279+ let userShare = getInteger(this, (((pool + "_") + toString(userAddress)) + keyUserShareTokensLocked))
280+ let lastInterest = valueOrErrorMessage(getInteger(this, (pool + keyLastInterest)), (("No data on the key: " + pool) + keyLastInterest))
281+ let userLastInterestValue = match userLastInterest {
282+ case userLastInterest: Int =>
283+ userLastInterest
284+ case _ =>
285+ lastInterest
286+ }
287+ let userShareTokensAmount = match userShare {
288+ case userShare: Int =>
289+ userShare
290+ case _ =>
291+ 0
292+ }
293+ $Tuple2(userLastInterestValue, userShareTokensAmount)
294+ }
295+
296+
297+func calcInterest (lastInterestHeight,rewardUpdateHeight,poolRewardUpdateHeight,lastInterest,currentRewardPerBlock,shareTokenLocked,previousRewardPerBlock,shareAssetId,scaleValue,pmtAmount) = if ((shareTokenLocked == 0))
298+ then 0
299+ else if ((poolRewardUpdateHeight != 0))
300+ then if (if ((rewardUpdateHeight > height))
301+ then (rewardUpdateHeight == poolRewardUpdateHeight)
302+ else false)
303+ then {
304+ let reward = (previousRewardPerBlock * (height - lastInterestHeight))
305+ (lastInterest + fraction(reward, scaleValue, shareTokenLocked))
306+ }
307+ else if (if ((height > rewardUpdateHeight))
308+ then (rewardUpdateHeight != poolRewardUpdateHeight)
309+ else false)
310+ then {
311+ let reward = (previousRewardPerBlock * (height - lastInterestHeight))
312+ (lastInterest + fraction(reward, scaleValue, shareTokenLocked))
313+ }
314+ else if (if (if ((height > rewardUpdateHeight))
315+ then (rewardUpdateHeight == poolRewardUpdateHeight)
316+ else false)
317+ then (lastInterestHeight > rewardUpdateHeight)
318+ else false)
319+ then {
320+ let reward = (currentRewardPerBlock * (height - lastInterestHeight))
321+ (lastInterest + fraction(reward, scaleValue, shareTokenLocked))
322+ }
323+ else {
324+ let rewardAfterLastInterestBeforeReawardUpdate = (previousRewardPerBlock * (rewardUpdateHeight - lastInterestHeight))
325+ let interestAfterUpdate = (lastInterest + fraction(rewardAfterLastInterestBeforeReawardUpdate, scaleValue, shareTokenLocked))
326+ let reward = (currentRewardPerBlock * (height - rewardUpdateHeight))
327+ (interestAfterUpdate + fraction(reward, scaleValue, shareTokenLocked))
328+ }
329+ else if ((rewardUpdateHeight > height))
330+ then {
331+ let reward = (previousRewardPerBlock * (height - lastInterestHeight))
332+ (lastInterest + fraction(reward, scaleValue, shareTokenLocked))
333+ }
334+ else if ((lastInterestHeight > rewardUpdateHeight))
335+ then {
336+ let reward = (currentRewardPerBlock * (height - lastInterestHeight))
337+ (lastInterest + fraction(reward, scaleValue, shareTokenLocked))
338+ }
339+ else {
340+ let rewardAfterLastInterestBeforeReawardUpdate = (previousRewardPerBlock * (rewardUpdateHeight - lastInterestHeight))
341+ let interestAfterUpdate = (lastInterest + fraction(rewardAfterLastInterestBeforeReawardUpdate, scaleValue, shareTokenLocked))
342+ let reward = (currentRewardPerBlock * (height - rewardUpdateHeight))
343+ (interestAfterUpdate + fraction(reward, scaleValue, shareTokenLocked))
344+ }
345+
346+
347+func claimCalc (pool,caller,pmtAmount) = {
348+ let shareAssetId = getShareAssetId(pool)
349+ let scaleValue = calcScaleValue(SWOP, shareAssetId)
350+ let shareTokenLocked = getTotalShareTokenLocked(pool)
351+ let $t01352213587 = getLastInterestInfo(pool)
352+ let lastInterestHeight = $t01352213587._1
353+ let lastInterest = $t01352213587._2
354+ let $t01359213704 = rewardInfo(pool)
355+ let currentRewardPerBlock = $t01359213704._1
356+ let rewardUpdateHeight = $t01359213704._2
357+ let previousRewardPerBlock = $t01359213704._3
358+ let poolRewardUpdateHeight = $t01359213704._4
359+ let $t01370913788 = getUserInterestInfo(pool, caller)
360+ let userLastInterest = $t01370913788._1
361+ let userShareTokensAmount = $t01370913788._2
362+ let currentInterest = calcInterest(lastInterestHeight, rewardUpdateHeight, poolRewardUpdateHeight, lastInterest, currentRewardPerBlock, shareTokenLocked, previousRewardPerBlock, shareAssetId, scaleValue, pmtAmount)
363+ let claimAmount = fraction(userShareTokensAmount, (currentInterest - userLastInterest), scaleValue)
364+ let userNewInterest = currentInterest
365+ $Tuple4(userNewInterest, currentInterest, claimAmount, userShareTokensAmount)
366+ }
367+
368+
369+func calculateProtocolReward (pool) = {
370+ let $t01430614371 = getLastInterestInfo(pool)
371+ let lastInterestHeight = $t01430614371._1
372+ let lastInterest = $t01430614371._2
373+ let $t01437614487 = rewardInfo(pool)
374+ let currentRewardPerBlock = $t01437614487._1
375+ let rewardUpdateHeight = $t01437614487._2
376+ let previousRewardPerBlock = $t01437614487._3
377+ let poolRewardUpdateHeight = $t01437614487._4
378+ let shareTokenLocked = getTotalShareTokenLocked(pool)
379+ if (if ((shareTokenLocked == 0))
380+ then (poolRewardUpdateHeight == 0)
381+ else false)
382+ then if ((rewardUpdateHeight > height))
383+ then {
384+ let reward = (previousRewardPerBlock * (height - lastInterestHeight))
385+ reward
386+ }
387+ else if ((lastInterestHeight > rewardUpdateHeight))
388+ then {
389+ let reward = (currentRewardPerBlock * (height - lastInterestHeight))
390+ reward
391+ }
392+ else {
393+ let rewardAfterLastInterestBeforeReawardUpdate = (previousRewardPerBlock * (rewardUpdateHeight - lastInterestHeight))
394+ let reward = (currentRewardPerBlock * (height - rewardUpdateHeight))
395+ (reward + rewardAfterLastInterestBeforeReawardUpdate)
396+ }
397+ else if (if ((shareTokenLocked == 0))
398+ then (poolRewardUpdateHeight != 0)
399+ else false)
400+ then if (if ((rewardUpdateHeight > height))
401+ then (rewardUpdateHeight == poolRewardUpdateHeight)
402+ else false)
403+ then {
404+ let reward = (previousRewardPerBlock * (height - lastInterestHeight))
405+ reward
406+ }
407+ else if (if ((height > rewardUpdateHeight))
408+ then (rewardUpdateHeight != poolRewardUpdateHeight)
409+ else false)
410+ then {
411+ let reward = (previousRewardPerBlock * (height - lastInterestHeight))
412+ reward
413+ }
414+ else if (if (if ((height > rewardUpdateHeight))
415+ then (rewardUpdateHeight == poolRewardUpdateHeight)
416+ else false)
417+ then (lastInterestHeight > rewardUpdateHeight)
418+ else false)
419+ then {
420+ let reward = (currentRewardPerBlock * (height - lastInterestHeight))
421+ reward
422+ }
423+ else {
424+ let rewardAfterLastInterestBeforeReawardUpdate = (previousRewardPerBlock * (rewardUpdateHeight - lastInterestHeight))
425+ let reward = (currentRewardPerBlock * (height - rewardUpdateHeight))
426+ (reward + rewardAfterLastInterestBeforeReawardUpdate)
427+ }
428+ else 0
429+ }
430+
431+
432+func checkPmtAssetIdCorrect (pool,pmtAssetId) = {
433+ let poolShareAssetId = fromBase58String(getStringValue(value(addressFromString(pool)), "share_asset_id"))
434+ if ((pmtAssetId == poolShareAssetId))
435+ then true
436+ else false
437+ }
438+
439+
440+func getUserSWOPClaimedAmount (pool,user) = valueOrElse(getInteger(this, (((pool + "_") + toString(user)) + keyUserSWOPClaimedAmount)), 0)
441+
442+
443+func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
444+
445+
446+@Callable(i)
447+func init (earlyLP) = if (isDefined(getString(this, keySWOPid)))
448+ then throw("SWOP already initialized")
449+ else {
450+ let initAmount = 100000000000000
451+ let SWOPissue = Issue("SWOP", "SWOP protocol token", initAmount, 8, true)
452+ let SWOPid = calculateAssetId(SWOPissue)
453+[BooleanEntry(keyActive, true), Issue("SWOP", "SWOP protocol token", initAmount, 8, true), StringEntry(keySWOPid, toBase58String(SWOPid))]
454+ }
455+
456+
457+
458+@Callable(i)
459+func initPoolShareFarming (pool) = if ((i.caller != this))
460+ then throw("Only the DApp itself can call this function")
461+ else {
462+ let $t01746917572 = rewardInfo(pool)
463+ let currentReward = $t01746917572._1
464+ let rewardUpdateHeight = $t01746917572._2
465+ let previousRewardPerBlock = $t01746917572._3
466+ let poolRewardUpdateHeight = $t01746917572._4
467+[IntegerEntry((pool + keyShareTokensLocked), 0), IntegerEntry((pool + keyLastInterest), 0), IntegerEntry((pool + keyLastInterestHeight), height)]
468+ }
469+
470+
471+
472+@Callable(i)
473+func updatePoolInterest (pool) = if ((i.caller != moneyBoxAddress))
474+ then throw("Only the Admin itself can call this function")
475+ else if (!(isActive))
476+ then throw("DApp is inactive at this moment")
477+ else {
478+ let $t01799018123 = claimCalc(pool, addressFromPublicKey(adminInvokePubKey), 0)
479+ let userNewInterest = $t01799018123._1
480+ let currentInterest = $t01799018123._2
481+ let claimAmount = $t01799018123._3
482+ let userShareTokensAmount = $t01799018123._4
483+ let $t01812818231 = rewardInfo(pool)
484+ let currentReward = $t01812818231._1
485+ let rewardUpdateHeight = $t01812818231._2
486+ let previousRewardPerBlock = $t01812818231._3
487+ let poolRewardUpdateHeight = $t01812818231._4
488+[IntegerEntry((pool + keyLastInterest), userNewInterest), IntegerEntry((pool + keyLastInterestHeight), height)]
489+ }
490+
491+
492+
493+@Callable(i)
494+func lockShareTokens (pool) = {
495+ let $t01842318498 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
496+ let pmtAmount = $t01842318498._1
497+ let pmtAssetId = $t01842318498._2
498+ let $t01850318576 = getAssetInfo(pmtAssetId)
499+ let pmtStrAssetId = $t01850318576._1
500+ let pmtAssetName = $t01850318576._2
501+ let pmtDecimals = $t01850318576._3
502+ let $t01858118698 = claimCalc(pool, i.originCaller, pmtAmount)
503+ let userNewInterest = $t01858118698._1
504+ let currentInterest = $t01858118698._2
505+ let claimAmount = $t01858118698._3
506+ let userShareTokensAmount = $t01858118698._4
507+ let userShareAmountNew = (userShareTokensAmount + pmtAmount)
508+ let availableFundsNew = (userAvailableSWOP(pool, i.originCaller) + claimAmount)
509+ let totalShareAmount = getTotalShareTokenLocked(pool)
510+ let totalShareAmountNew = (totalShareAmount + pmtAmount)
511+ let userClaimedAmount = getUserSWOPClaimedAmount(pool, i.originCaller)
512+ let userClaimedAmountNew = (userClaimedAmount + claimAmount)
513+ let baseEntry = [IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserLastInterest), userNewInterest), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserShareTokensLocked), userShareAmountNew), IntegerEntry((pool + keyShareTokensLocked), totalShareAmountNew), IntegerEntry((pool + keyLastInterest), currentInterest), IntegerEntry((pool + keyLastInterestHeight), height), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserSWOPLastClaimedAmount), claimAmount), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyAvailableSWOP), availableFundsNew)]
514+ let uplp = if ((getString(Address(fromBase58String(pool)), "version") == "3.0.0"))
515+ then invoke(lpFarmingAddress, "updateUserInterest", [pool, userShareAmountNew], nil)
516+ else 0
517+ if ((uplp == uplp))
518+ then if ((0 >= pmtAmount))
519+ then throw("You can't lock token")
520+ else if (!(isActive))
521+ then throw("DApp is inactive at this moment")
522+ else if (!(checkPmtAssetIdCorrect(pool, pmtAssetId)))
523+ then throw("Incorrect pmtAssetId")
524+ else if (if (isFirstHarvest(Address(fromBase58String(pool))))
525+ then (getHeightFirstHarvest(Address(fromBase58String(pool))) > height)
526+ else false)
527+ then {
528+ let harvestPeriod = ((((getHeightFirstHarvest(Address(fromBase58String(pool))) - startHeight) + 1) / periodLength) - 1)
529+ let amountOfVoting = split(getStringValue(votingAddress, (((toString(i.originCaller) + "_") + pool) + "_user_pool_struc")), "_")
530+ let amountPoolStract = split(getStringValue(votingAddress, (pool + "_pool_struc")), "_")
531+ let amountActiveVoteUserPoolStract = split(valueOrElse(getString(votingAddress, (((toString(i.originCaller) + "_") + pool) + kHarvestUserPoolActiveVoteStrucVoting)), ""), "_")
532+ let amountPoolActiveVoteStract = split(valueOrElse(getString(votingAddress, (pool + kHarvestPoolActiveVoteStrucVoting)), ""), "_")
533+ let userShareTokenLocked = userShareTokensAmount
534+ let userPoolActiveVote = if ((toString(currPeriod) == amountOfVoting[2]))
535+ then valueOrElse(parseInt(amountActiveVoteUserPoolStract[0]), 0)
536+ else valueOrElse(parseInt(amountOfVoting[1]), 0)
537+ let poolActiveVote = if ((toString(currPeriod) == amountPoolStract[2]))
538+ then valueOrElse(parseInt(amountPoolActiveVoteStract[0]), 0)
539+ else valueOrElse(parseInt(amountPoolStract[1]), 0)
540+ let protocolReward = calculateProtocolReward(pool)
541+ if ((userPoolActiveVote != 0))
542+ then {
543+ let limitShareToken = getShareLimitToken(addressFromStringValue(pool))
544+ let shareToken = (fraction(limitShareToken, userPoolActiveVote, poolActiveVote) - userShareTokenLocked)
545+ if (if ((size(amountActiveVoteUserPoolStract) > 1))
546+ then (valueOrElse(parseInt(amountActiveVoteUserPoolStract[1]), 0) >= harvestPeriod)
547+ else false)
548+ then throw("You can't share token")
549+ else if ((pmtAmount > limitShareToken))
550+ then throw(("You can't share token more than " + toString(limitShareToken)))
551+ else if ((shareToken > 0))
552+ then if ((fraction(99, accountBalance(pmtAssetId), 100) > totalShareAmountNew))
553+ then throw("Balance of share-token is greater than totalAmount")
554+ else if ((totalShareAmount == 0))
555+ then (baseEntry ++ [Reissue(SWOP, protocolReward, true), ScriptTransfer(moneyBoxAddress, protocolReward, SWOP)])
556+ else if ((shareToken >= pmtAmount))
557+ then baseEntry
558+ else throw(("Your maximum share token is " + toString(shareToken)))
559+ else throw("You can't share token")
560+ }
561+ else throw("Your amount of token less than 0")
562+ }
563+ else baseEntry
564+ else throw("Strict value is not equal to itself.")
565+ }
566+
567+
568+
569+@Callable(i)
570+func withdrawShareTokens (pool,shareTokensWithdrawAmount) = {
571+ let shareTokensId = fromBase58String(getStringValue(value(addressFromString(pool)), "share_asset_id"))
572+ let $t02331023421 = claimCalc(pool, i.originCaller, 1)
573+ let userNewInterest = $t02331023421._1
574+ let currentInterest = $t02331023421._2
575+ let claimAmount = $t02331023421._3
576+ let userShareTokensAmount = $t02331023421._4
577+ let userShareAmountNew = (userShareTokensAmount - shareTokensWithdrawAmount)
578+ let availableFundsNew = (userAvailableSWOP(pool, i.originCaller) + claimAmount)
579+ let totalShareAmount = getTotalShareTokenLocked(pool)
580+ let totalShareAmountNew = (totalShareAmount - shareTokensWithdrawAmount)
581+ let userClaimedAmount = getUserSWOPClaimedAmount(pool, i.originCaller)
582+ let userClaimedAmountNew = (userClaimedAmount + claimAmount)
583+ if ((shareTokensWithdrawAmount > userShareTokensAmount))
584+ then throw("Withdraw amount more then user locked amount")
585+ else if (!(isActive))
586+ then throw("DApp is inactive at this moment")
587+ else if ((shareTokensWithdrawAmount > userShareTokensAmount))
588+ then throw("Withdraw amount more then user locked amount")
589+ else if ((fraction(99, (accountBalance(shareTokensId) - shareTokensWithdrawAmount), 100) > totalShareAmountNew))
590+ then throw("Balance of share-token is greater than totalAmount")
591+ else {
592+ let uplp = if ((getString(Address(fromBase58String(pool)), "version") == "3.0.0"))
593+ then invoke(lpFarmingAddress, "updateUserInterest", [pool, userShareAmountNew], nil)
594+ else 0
595+ if ((uplp == uplp))
596+ then [IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserLastInterest), userNewInterest), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserShareTokensLocked), userShareAmountNew), IntegerEntry((pool + keyLastInterest), currentInterest), IntegerEntry((pool + keyLastInterestHeight), height), IntegerEntry((pool + keyShareTokensLocked), totalShareAmountNew), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyAvailableSWOP), availableFundsNew), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((((pool + "_") + toString(i.originCaller)) + keyUserSWOPLastClaimedAmount), claimAmount), ScriptTransfer(i.caller, shareTokensWithdrawAmount, shareTokensId)]
597+ else throw("Strict value is not equal to itself.")
598+ }
599+ }
600+
601+
602+
603+@Callable(i)
604+func claim (pool) = {
605+ let shareTokensId = fromBase58String(getStringValue(value(addressFromString(pool)), "share_asset_id"))
606+ let shareTokenLocked = getTotalShareTokenLocked(pool)
607+ let $t02568925755 = getLastInterestInfo(pool)
608+ let lastInterestHeight = $t02568925755._1
609+ let lastInterest = $t02568925755._2
610+ let $t02576025874 = rewardInfo(pool)
611+ let currentRewardPerBlock = $t02576025874._1
612+ let rewardUpdateHeight = $t02576025874._2
613+ let previousRewardPerBlock = $t02576025874._3
614+ let poolRewardUpdateHeight = $t02576025874._4
615+ let $t02587925984 = claimCalc(pool, i.caller, 1)
616+ let userNewInterest = $t02587925984._1
617+ let currentInterest = $t02587925984._2
618+ let claimAmount = $t02587925984._3
619+ let userShareTokensAmount = $t02587925984._4
620+ let availableFund = (userAvailableSWOP(pool, i.caller) + claimAmount)
621+ let userClaimedAmount = getUserSWOPClaimedAmount(pool, i.caller)
622+ let userClaimedAmountNew = (userClaimedAmount + claimAmount)
623+ if ((availableFund == 0))
624+ then throw("You have 0 available SWOP")
625+ else if (!(isActive))
626+ then throw("DApp is inactive at this moment")
627+ else if ((availableFund == 0))
628+ then throw("You have 0 available SWOP")
629+ else if ((fraction(99, accountBalance(shareTokensId), 100) > shareTokenLocked))
630+ then throw("Balance of share-token is greater than totalAmount")
631+ else [IntegerEntry((((pool + "_") + toString(i.caller)) + keyUserLastInterest), userNewInterest), IntegerEntry((pool + keyLastInterest), currentInterest), IntegerEntry((pool + keyLastInterestHeight), height), IntegerEntry((((pool + "_") + toString(i.caller)) + keyAvailableSWOP), 0), Reissue(SWOP, availableFund, true), IntegerEntry((((pool + "_") + toString(i.caller)) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((((pool + "_") + toString(i.caller)) + keyUserSWOPLastClaimedAmount), claimAmount), ScriptTransfer(i.caller, availableFund, SWOP)]
632+ }
633+
634+
635+
636+@Callable(i)
637+func shutdown () = if (!(isActive))
638+ then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, keyCause), "the cause wasn't specified")))
639+ else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey)))
640+ then throw("Only admin can call this function")
641+ else suspend("Paused by admin")
642+
643+
644+
645+@Callable(i)
646+func activate () = if (isActive)
647+ then throw("DApp is already active")
648+ else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey)))
649+ then throw("Only admin can call this function")
650+ else [BooleanEntry(keyActive, true), DeleteEntry(keyCause)]
651+
652+
653+@Verifier(tx)
654+func verify () = match tx {
655+ case _ =>
656+ let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
657+ then 1
658+ else 0
659+ let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
660+ then 1
661+ else 0
662+ let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
663+ then 1
664+ else 0
665+ (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
666+}
667+

github/deemru/w8io/026f985 
47.81 ms