tx · 2yZVVqyvpU9eAVijdxmzTnhiR2ygZ5WMFcSHxH6pue5V

3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C:  -0.02400000 Waves

2022.08.08 10:48 [3240707] smart account 3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2yZVVqyvpU9eAVijdxmzTnhiR2ygZ5WMFcSHxH6pue5V",
    "fee": 2400000,
    "feeAssetId": null,
    "timestamp": 1659941385166,
    "version": 1,
    "sender": "3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C",
    "senderPublicKey": "BYLtcNg4P4UcUd6tFdxeuhyRqgkYZujzyfwdEHNmo89c",
    "proofs": [
        "3KnCs8mrRyPzJhwfTpqSHySR3By4WWMAnfEL8D9NmpU8nCgmTzqPLLbYxn58M1tDjyPVEyyzGZnWUMYEhByjnqPV"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3240707,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: JC5Tc3eau8MEGK75s9k1iX3r49bHbb7XVXsSf6EDu6X5

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let revisionNum = "cbd0bdc8bbba91db64066b16a84913a4c965e23e"
5+
6+let separator = "__"
7+
8+let SEP = "__"
9+
10+let MULT6 = 1000000
11+
12+let MULT8 = 100000000
13+
14+let MULTX6 = toBigInt(MULT6)
15+
16+let MULTX8 = toBigInt(MULT8)
17+
18+let MULTX18 = toBigInt(1000000000000000000)
19+
20+let WAVESIDSTR = "WAVES"
21+
22+let WAVESID = fromBase58String(WAVESIDSTR)
23+
24+let IdxControlCfgNeutrinoDapp = 1
25+
26+let IdxControlCfgAuctionDapp = 2
27+
28+let IdxControlCfgRpdDapp = 3
29+
30+let IdxControlCfgMathDapp = 4
31+
32+let IdxControlCfgLiquidationDapp = 5
33+
34+let IdxControlCfgRestDapp = 6
35+
36+let IdxControlCfgNodeRegistryDapp = 7
37+
38+let IdxControlCfgNsbtStakingDapp = 8
39+
40+let IdxControlCfgMediatorDapp = 9
41+
42+let IdxControlCfgSurfStakingDapp = 10
43+
44+let IdxControlCfgGnsbtControllerDapp = 11
45+
46+func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
47+
48+
49+func keyControlAddress () = "%s%s__config__controlAddress"
50+
51+
52+func keyControlCfg () = "%s__controlConfig"
53+
54+
55+func keyGnsbtFromSurfCoeff () = "%s%s__cfg__gnsbtFromSurfCoeff"
56+
57+
58+func readControlCfgOrFail (control) = split(getStringOrFail(control, keyControlCfg()), SEP)
59+
60+
61+func getContractAddressOrFail (controlCfg,idx) = valueOrErrorMessage(addressFromString(controlCfg[idx]), ("Control cfg doesn't contain address at index " + toString(idx)))
62+
63+
64+let controlContract = addressFromStringValue(valueOrElse(getString(this, keyControlAddress()), "3P5Bfd58PPfNvBM2Hy8QfbcDqMeNtzg7KfP"))
65+
66+let controlCfg = readControlCfgOrFail(controlContract)
67+
68+let mathContract = getContractAddressOrFail(controlCfg, IdxControlCfgMathDapp)
69+
70+let neutrinoContract = getContractAddressOrFail(controlCfg, IdxControlCfgNeutrinoDapp)
71+
72+let auctionContract = getContractAddressOrFail(controlCfg, IdxControlCfgAuctionDapp)
73+
74+let gnsbtFromSurfCoeff = valueOrElse(getInteger(this, keyGnsbtFromSurfCoeff()), 300)
75+
76+func keyBondAsset () = "bond_asset_id"
77+
78+
79+func keyAuctionContractAddress () = "auction_contract"
80+
81+
82+func keyMinLockAmount () = "%s__minLockAmount"
83+
84+
85+func keyStakedAssetId () = "%s__stakedAssetId"
86+
87+
88+func keyLockParamUserAmount (userAddress) = makeString(["%s%s%s", "paramByUser", toString(userAddress), "amount"], separator)
89+
90+
91+func keyLockParamStartBlock (userAddress) = makeString(["%s%s%s", "paramByUser", toString(userAddress), "start"], separator)
92+
93+
94+func keyLockParamVotingPowerEffectiveHeight (userAddress) = makeString(["%s%s%s", "paramByUser", toString(userAddress), "vpEffectiveHeight"], separator)
95+
96+
97+func keyHistoryRecord (type,userAddress,txId) = makeString(["%s%s%s%s", "history", type, toString(userAddress), toBase58String(txId)], separator)
98+
99+
100+func keyLockParamTotalAmount () = makeString(["%s%s", "stats", "activeTotalLocked"], separator)
101+
102+
103+func keyStatsLocksCount () = makeString(["%s%s", "stats", "locksCount"], separator)
104+
105+
106+func keyStatsUsersCount () = makeString(["%s%s", "stats", "activeUsersCount"], separator)
107+
108+
109+func keyNextPeriod () = "%s__nextPeriod"
110+
111+
112+func keySupportedRewardAssets () = "supportedRewardAssets"
113+
114+
115+func keyDepositNumLast () = makeString(["%s%s%s", "dep", "lastNum"], separator)
116+
117+
118+func keyUserRewardFromDepositNum (userAddress) = makeString(["%s%s%s", "userRwdFromDepNum", userAddress], separator)
119+
120+
121+func keyRewardPerNsbtSumAt (depositNum,tkn) = makeString(["%s%d", "rwdPerNsbtSumByDepNum", toString(depositNum), tkn], separator)
122+
123+
124+func keyReward (userAddress,tkn) = makeString(["%s%s%s", "rwd", userAddress, tkn], separator)
125+
126+
127+func keyClaimed (userAddress,tkn) = makeString(["%s%s%s", "clm", userAddress, tkn], separator)
128+
129+
130+func keyNotDistributedReward (tkn) = makeString(["%s%s", "notDistributed", tkn], separator)
131+
132+
133+func toX18 (origVal,origMult) = fraction(toBigInt(origVal), MULTX18, origMult)
134+
135+
136+func getIntOrZero (key) = valueOrElse(getInteger(this, key), 0)
137+
138+
139+func getIntOrElse (key,defaultVal) = valueOrElse(getInteger(this, key), defaultVal)
140+
141+
142+func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), (("Mandatory this." + key) + " is not defined"))
143+
144+
145+func getStrOrElse (key,defaultVal) = valueOrElse(getString(this, key), defaultVal)
146+
147+
148+func toAddressOrFail (addressStr) = valueOrErrorMessage(addressFromString(addressStr), ("couldn't parse passed addressStr=" + addressStr))
149+
150+
151+func toAssetVect (assetStr) = if ((assetStr == WAVESIDSTR))
152+    then unit
153+    else fromBase58String(assetStr)
154+
155+
156+func asInt (val) = match val {
157+    case valInt: Int => 
158+        valInt
159+    case _ => 
160+        throw("fail to cast into Int")
161+}
162+
163+
164+func formatHistoryRecord (oldAmount,oldStart,newAmount,newStart) = makeString(["%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(oldAmount), toString(oldStart), toString(newAmount), toString(newStart)], separator)
165+
166+
167+func formatClaimHistoryRecord (user,claimedRewards) = makeString(["%s%d%d%s", user, toString(lastBlock.height), toString(lastBlock.timestamp), claimedRewards], separator)
168+
169+
170+func HistoryRecordEntry (type,userAddress,txId,oldAmount,oldStart,newAmount,newStart) = StringEntry(keyHistoryRecord(type, userAddress, txId), formatHistoryRecord(oldAmount, oldStart, newAmount, newStart))
171+
172+
173+func ClaimHistoryEntry (userAddress,txId,claimedRewards) = StringEntry(keyHistoryRecord("claim", userAddress, txId), formatClaimHistoryRecord(toString(userAddress), claimedRewards))
174+
175+
176+func StatsResult (totalLockedInc,lockCountInc,usersCountInc) = {
177+    let locksCount = getIntOrZero(keyStatsLocksCount())
178+    let usersCount = getIntOrZero(keyStatsUsersCount())
179+    let totalAmount = getIntOrZero(keyLockParamTotalAmount())
180+    let totalAmountNew = (totalAmount + totalLockedInc)
181+    $Tuple3([IntegerEntry(keyStatsLocksCount(), (locksCount + lockCountInc)), IntegerEntry(keyStatsUsersCount(), (usersCount + usersCountInc)), IntegerEntry(keyLockParamTotalAmount(), totalAmountNew)], totalAmount, totalAmountNew)
182+    }
183+
184+
185+func LockParamsEntry (userAddress,amount,votingPowerEffectiveHeight) = [IntegerEntry(keyLockParamUserAmount(userAddress), amount), IntegerEntry(keyLockParamStartBlock(userAddress), votingPowerEffectiveHeight)]
186+
187+
188+func getParamsOrFail () = $Tuple2(fromBase58String(getStringOrFail(this, keyStakedAssetId())), getIntOrFail(keyMinLockAmount()))
189+
190+
191+func isActiveUser (userAddress) = (getIntOrElse(keyLockParamUserAmount(userAddress), 0) > 0)
192+
193+
194+func getUserParamsOrUnit (userAddress) = if (isActiveUser(userAddress))
195+    then $Tuple3(false, getIntOrFail(keyLockParamUserAmount(userAddress)), getIntOrFail(keyLockParamStartBlock(userAddress)))
196+    else unit
197+
198+
199+func getUserParamsOrFail (userAddress) = valueOrErrorMessage(getUserParamsOrUnit(userAddress), (("User " + toString(userAddress)) + " is not defined"))
200+
201+
202+let supportedAssetsStr = getStrOrElse(keySupportedRewardAssets(), "")
203+
204+let supportedAssetsList = split(supportedAssetsStr, "_")
205+
206+func calcReward (userAddress,assetId,stakedAmountX,depositNumUser,depositNumLast) = {
207+    let rewardPerNsbtSumLastKEY = keyRewardPerNsbtSumAt(depositNumLast, assetId)
208+    let sumLastX18 = parseBigIntValue(getStrOrElse(keyRewardPerNsbtSumAt(depositNumLast, assetId), "0"))
209+    let sumUserX18 = parseBigIntValue(getStrOrElse(keyRewardPerNsbtSumAt(depositNumUser, assetId), "0"))
210+    let rewardDynamicPart = toInt(fraction((sumLastX18 - sumUserX18), stakedAmountX, MULTX18))
211+    let rewardCachedPartKEY = keyReward(userAddress, assetId)
212+    let rewardCachedPart = getIntOrElse(rewardCachedPartKEY, 0)
213+    $Tuple4((rewardCachedPart + rewardDynamicPart), rewardCachedPart, rewardDynamicPart, rewardCachedPartKEY)
214+    }
215+
216+
217+func RewardEntries (isNewUser,userAddress,stakedAmount) = {
218+    let stakedAmountX = toBigInt(stakedAmount)
219+    let userRewardFromDepositNumKEY = keyUserRewardFromDepositNum(userAddress)
220+    let depositNumUser = getIntOrElse(userRewardFromDepositNumKEY, -1)
221+    let depositNumLast = getIntOrElse(keyDepositNumLast(), -1)
222+    func forEachAssetCacheUserReward (accum,asset) =     {
223+        let $t088308965 = calcReward(userAddress, asset, stakedAmountX, depositNumUser, depositNumLast)
224+        let rewardTotal = $t088308965._1
225+        let cached = $t088308965._2
226+        let dynamic = $t088308965._3
227+        let rewardCachedPartKEY = $t088308965._4
228+        (accum :+ IntegerEntry(rewardCachedPartKEY, rewardTotal))
229+        }
230+
231+    if (if ((depositNumLast == -1))
232+        then (depositNumUser == -1)
233+        else false)
234+        then nil
235+        else if (if ((depositNumLast == -1))
236+            then (depositNumUser > -1)
237+            else false)
238+            then throw("invalid depositNumLast and depositNumUser state")
239+            else if (if ((depositNumLast > -1))
240+                then (depositNumUser >= -1)
241+                else false)
242+                then if (isNewUser)
243+                    then [IntegerEntry(userRewardFromDepositNumKEY, depositNumLast)]
244+                    else ({
245+                        let $l = supportedAssetsList
246+                        let $s = size($l)
247+                        let $acc0 = nil
248+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
249+                            then $a
250+                            else forEachAssetCacheUserReward($a, $l[$i])
251+
252+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
253+                            then $a
254+                            else throw("List size exceeds 10")
255+
256+                        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
257+                        } :+ IntegerEntry(userRewardFromDepositNumKEY, depositNumLast))
258+                else throw(((("uncovered condition: depositNumLast=" + toString(depositNumLast)) + " depositNumUser=") + toString(depositNumUser)))
259+    }
260+
261+
262+func IncrementNotDistributedRewardEntry (tkn,amountInc) = {
263+    let notDistributedRewardKEY = keyNotDistributedReward(tkn)
264+    let notDistributedReward = getIntOrElse(notDistributedRewardKEY, 0)
265+[IntegerEntry(notDistributedRewardKEY, (notDistributedReward + amountInc))]
266+    }
267+
268+
269+func surfToGnsbt (surfAmt) = (surfAmt / gnsbtFromSurfCoeff)
270+
271+
272+func mergeVotingPowerEffectiveHeight (quarantinePeriod,vpEffectiveHeight,stakedAmt,stakedAmtNEW) = {
273+    let remainingToWait = (vpEffectiveHeight - height)
274+    if ((0 >= remainingToWait))
275+        then (height + quarantinePeriod)
276+        else {
277+            let alreadyWaited = (quarantinePeriod - remainingToWait)
278+            let kX8 = if ((stakedAmtNEW != 0))
279+                then fraction(stakedAmt, MULT8, stakedAmtNEW)
280+                else vpEffectiveHeight
281+            ((quarantinePeriod + height) - fraction(alreadyWaited, kX8, MULT8))
282+            }
283+    }
284+
285+
286+func mergeStake (userAddress,amountToAdd) = {
287+    let $t01261812728 = valueOrElse(getUserParamsOrUnit(userAddress), $Tuple3(true, 0, 0))
288+    let isNewUser = $t01261812728._1
289+    let stakedAmount = $t01261812728._2
290+    let vpEffectiveHeight = $t01261812728._3
291+    let stakedAmountNEW = if (isNewUser)
292+        then amountToAdd
293+        else (amountToAdd + stakedAmount)
294+    let quarantinePeriod = (1440 * 14)
295+    let vpEffectiveHeightNEW = if (isNewUser)
296+        then (quarantinePeriod + height)
297+        else mergeVotingPowerEffectiveHeight(quarantinePeriod, vpEffectiveHeight, stakedAmount, stakedAmountNEW)
298+    $Tuple5(isNewUser, stakedAmount, vpEffectiveHeight, stakedAmountNEW, vpEffectiveHeightNEW)
299+    }
300+
301+
302+func commonStake (userAddress,i) = {
303+    let $t01321413268 = getParamsOrFail()
304+    let stakedAssetId = $t01321413268._1
305+    let minLockAmount = $t01321413268._2
306+    if ((size(i.payments) != 1))
307+        then throw("Invalid payments size")
308+        else {
309+            let payment = i.payments[0]
310+            let amount = payment.amount
311+            let invalidAssetMessage = (("Invalid asset. " + toBase58String(stakedAssetId)) + " is expected")
312+            let assetId = valueOrErrorMessage(payment.assetId, invalidAssetMessage)
313+            if ((assetId != stakedAssetId))
314+                then throw(invalidAssetMessage)
315+                else {
316+                    let userAddressStr = toString(userAddress)
317+                    let mergedData = mergeStake(userAddress, amount)
318+                    let isNewUser = mergedData._1
319+                    let stakedAmount = mergedData._2
320+                    let vpEffectiveHeight = mergedData._3
321+                    let stakedAmountNEW = mergedData._4
322+                    let vpEffectiveHeightNEW = mergedData._5
323+                    if ((minLockAmount > stakedAmountNEW))
324+                        then throw(("Min lock amount is " + toString(minLockAmount)))
325+                        else {
326+                            let $t01406714169 = StatsResult(amount, 1, if (isNewUser)
327+                                then 1
328+                                else 0)
329+                            let statsEntries = $t01406714169._1
330+                            let totalStaked = $t01406714169._2
331+                            let totalStakedNew = $t01406714169._3
332+                            ((([HistoryRecordEntry("stake", userAddress, i.transactionId, stakedAmount, vpEffectiveHeight, stakedAmountNEW, vpEffectiveHeightNEW)] ++ RewardEntries(isNewUser, userAddressStr, stakedAmount)) ++ LockParamsEntry(userAddress, stakedAmountNEW, vpEffectiveHeightNEW)) ++ statsEntries)
333+                            }
334+                    }
335+            }
336+    }
337+
338+
339+func commonClaim (userAddress,i) = {
340+    let userAddressStr = toString(userAddress)
341+    if ((size(i.payments) > 0))
342+        then throw("payments are not accepted")
343+        else {
344+            let $t01464814753 = valueOrElse(getUserParamsOrUnit(userAddress), $Tuple3(true, 0, 0))
345+            let isNewUser = $t01464814753._1
346+            let stakedAmount = $t01464814753._2
347+            let stakingStart = $t01464814753._3
348+            let stakedAmountX = toBigInt(stakedAmount)
349+            let userRewardFromDepositNumKEY = keyUserRewardFromDepositNum(userAddressStr)
350+            let depositNumUser = getIntOrElse(userRewardFromDepositNumKEY, -1)
351+            let depositNumLast = getIntOrElse(keyDepositNumLast(), -1)
352+            func forEachAssetCalcUnclaimedReward (accum,asset) =             {
353+                let $t01512415262 = calcReward(userAddressStr, asset, stakedAmountX, depositNumUser, depositNumLast)
354+                let rewardTotal = $t01512415262._1
355+                let cached = $t01512415262._2
356+                let dynamic = $t01512415262._3
357+                let rewardCachedPartKEY = $t01512415262._4
358+                let claimedKEY = keyClaimed(userAddressStr, asset)
359+                let $t01532215359 = accum
360+                let data = $t01532215359._1
361+                let claimedAmtByAsset = $t01532215359._2
362+                let newPart = makeString([asset, toString(rewardTotal)], ":")
363+                let claimedAmtByAssetNew = makeString([claimedAmtByAsset, newPart], "_")
364+                if ((0 >= rewardTotal))
365+                    then $Tuple2(data, claimedAmtByAssetNew)
366+                    else $Tuple2((((data :+ ScriptTransfer(userAddress, rewardTotal, toAssetVect(asset))) :+ IntegerEntry(claimedKEY, (valueOrElse(getInteger(claimedKEY), 0) + rewardTotal))) :+ IntegerEntry(rewardCachedPartKEY, 0)), claimedAmtByAssetNew)
367+                }
368+
369+            let $t01581915933 = {
370+                let $l = supportedAssetsList
371+                let $s = size($l)
372+                let $acc0 = $Tuple2(nil, "")
373+                func $f0_1 ($a,$i) =                 if (($i >= $s))
374+                    then $a
375+                    else forEachAssetCalcUnclaimedReward($a, $l[$i])
376+
377+                func $f0_2 ($a,$i) =                 if (($i >= $s))
378+                    then $a
379+                    else throw("List size exceeds 10")
380+
381+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
382+                }
383+            let transfers = $t01581915933._1
384+            let claimedAmtByAssetResult = $t01581915933._2
385+            if ((0 >= size(transfers)))
386+                then nil
387+                else ((transfers :+ IntegerEntry(userRewardFromDepositNumKEY, depositNumLast)) :+ ClaimHistoryEntry(userAddress, i.transactionId, drop(claimedAmtByAssetResult, 1)))
388+            }
389+    }
390+
391+
392+@Callable(i)
393+func constructor (minLockAmount,supportedRewardAssets,stakedAssetId) = if ((i.caller != this))
394+    then throw("Permission denied")
395+    else [IntegerEntry(keyMinLockAmount(), minLockAmount), StringEntry(keySupportedRewardAssets(), supportedRewardAssets), StringEntry(keyStakedAssetId(), stakedAssetId)]
396+
397+
398+
399+@Callable(i)
400+func stake () = commonStake(i.caller, i)
401+
402+
403+
404+@Callable(i)
405+func stakeByOriginCaller () = commonStake(i.originCaller, i)
406+
407+
408+
409+@Callable(i)
410+func unstake (amount) = if ((size(i.payments) != 0))
411+    then throw("unstake doesn't require any payment")
412+    else {
413+        let userAddress = i.caller
414+        let userAddressStr = toString(userAddress)
415+        let $t01684216896 = getParamsOrFail()
416+        let stakedAssetId = $t01684216896._1
417+        let minLockAmount = $t01684216896._2
418+        let $t01689916983 = getUserParamsOrFail(userAddress)
419+        let isNewUser = $t01689916983._1
420+        let stakedAmount = $t01689916983._2
421+        let vpEffectiveHeight = $t01689916983._3
422+        if ((0 >= stakedAmount))
423+            then throw("Nothing to unstake")
424+            else if ((amount > stakedAmount))
425+                then throw(((("Requested " + toString(amount)) + ", but staked only ") + toString(stakedAmount)))
426+                else {
427+                    let stakedAmountNEW = (stakedAmount - amount)
428+                    let $t01722517383 = StatsResult(-(amount), if ((amount == stakedAmount))
429+                        then -1
430+                        else 0, if ((amount == stakedAmount))
431+                        then -1
432+                        else 0)
433+                    let statsEntries = $t01722517383._1
434+                    let totalStaked = $t01722517383._2
435+                    let totalStakedNew = $t01722517383._3
436+                    ((([ScriptTransfer(userAddress, amount, stakedAssetId), HistoryRecordEntry("unstake", userAddress, i.transactionId, stakedAmount, vpEffectiveHeight, stakedAmountNEW, vpEffectiveHeight)] ++ RewardEntries(false, userAddressStr, stakedAmount)) ++ LockParamsEntry(userAddress, stakedAmountNEW, vpEffectiveHeight)) ++ statsEntries)
437+                    }
438+        }
439+
440+
441+
442+@Callable(i)
443+func deposit () = if ((size(i.payments) != 1))
444+    then throw("exact 1 payment is allowed only")
445+    else {
446+        let pmt = i.payments[0]
447+        let amount = pmt.amount
448+        let pmtAssetId = valueOrElse(pmt.assetId, WAVESID)
449+        let pmtAssetIdStr = toBase58String(pmtAssetId)
450+        let pmtMultX = if ((pmtAssetId == WAVESID))
451+            then MULTX8
452+            else MULTX6
453+        let amountX = toBigInt(amount)
454+        let totalStaked = getIntOrElse(keyLockParamTotalAmount(), 0)
455+        let totalStakedX = toBigInt(totalStaked)
456+        if ((0 > totalStaked))
457+            then throw("TODO: case is not supported")
458+            else if ((totalStaked == 0))
459+                then IncrementNotDistributedRewardEntry(pmtAssetIdStr, amount)
460+                else {
461+                    let rewardPerNsbtX18 = fraction(amountX, MULTX18, totalStakedX)
462+                    let depositNumLastKEY = keyDepositNumLast()
463+                    let depositNumLast = getIntOrElse(depositNumLastKEY, -1)
464+                    let depositNumNew = (depositNumLast + 1)
465+                    if (!(contains(supportedAssetsStr, pmtAssetIdStr)))
466+                        then throw(((supportedAssetsStr + " doesn't contain ") + pmtAssetIdStr))
467+                        else {
468+                            func refreshRewardPerNsbtSUM (accum,nextAsset) =                             {
469+                                let rewardPerNsbtSumNewKEY = keyRewardPerNsbtSumAt(depositNumNew, nextAsset)
470+                                let sumLastStr = getStrOrElse(keyRewardPerNsbtSumAt(depositNumLast, nextAsset), "0")
471+                                (accum :+ (if ((nextAsset == pmtAssetIdStr))
472+                                    then StringEntry(rewardPerNsbtSumNewKEY, toString((parseBigIntValue(sumLastStr) + rewardPerNsbtX18)))
473+                                    else StringEntry(rewardPerNsbtSumNewKEY, sumLastStr)))
474+                                }
475+
476+                            ({
477+                                let $l = supportedAssetsList
478+                                let $s = size($l)
479+                                let $acc0 = nil
480+                                func $f0_1 ($a,$i) =                                 if (($i >= $s))
481+                                    then $a
482+                                    else refreshRewardPerNsbtSUM($a, $l[$i])
483+
484+                                func $f0_2 ($a,$i) =                                 if (($i >= $s))
485+                                    then $a
486+                                    else throw("List size exceeds 10")
487+
488+                                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
489+                                } :+ IntegerEntry(depositNumLastKEY, depositNumNew))
490+                            }
491+                    }
492+        }
493+
494+
495+
496+@Callable(i)
497+func claimRewards () = commonClaim(i.caller, i)
498+
499+
500+
501+@Callable(i)
502+func claimRewardsByOriginCaller () = commonClaim(i.originCaller, i)
503+
504+
505+
506+@Callable(i)
507+func unclaimedRewardsREADONLY (userAddressStr) = {
508+    func forEachAssetZeroReward (accum,asset) =     ((accum + makeString([asset, "0", "0"], ":")) + "_")
509+
510+    let unclaimedRewardStr = if ((userAddressStr == ""))
511+        then {
512+            let $l = supportedAssetsList
513+            let $s = size($l)
514+            let $acc0 = ""
515+            func $f0_1 ($a,$i) =             if (($i >= $s))
516+                then $a
517+                else forEachAssetZeroReward($a, $l[$i])
518+
519+            func $f0_2 ($a,$i) =             if (($i >= $s))
520+                then $a
521+                else throw("List size exceeds 10")
522+
523+            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
524+            }
525+        else {
526+            let userAddress = addressFromStringValue(userAddressStr)
527+            let $t01995720062 = valueOrElse(getUserParamsOrUnit(userAddress), $Tuple3(true, 0, 0))
528+            let isNewUser = $t01995720062._1
529+            let stakedAmount = $t01995720062._2
530+            let stakingStart = $t01995720062._3
531+            let stakedAmountX = toBigInt(stakedAmount)
532+            let userRewardFromDepositNumKEY = keyUserRewardFromDepositNum(userAddressStr)
533+            let depositNumUser = getIntOrElse(userRewardFromDepositNumKEY, -1)
534+            let depositNumLast = getIntOrElse(keyDepositNumLast(), -1)
535+            func forEachAssetCalcUnclaimedReward (accum,asset) =             {
536+                let $t02040820546 = calcReward(userAddressStr, asset, stakedAmountX, depositNumUser, depositNumLast)
537+                let rewardTotal = $t02040820546._1
538+                let cached = $t02040820546._2
539+                let dynamic = $t02040820546._3
540+                let rewardCachedPartKEY = $t02040820546._4
541+                let claimed = valueOrElse(getInteger(keyClaimed(userAddressStr, asset)), 0)
542+                ((accum + makeString([asset, toString(rewardTotal), toString(claimed)], ":")) + "_")
543+                }
544+
545+            let $l = supportedAssetsList
546+            let $s = size($l)
547+            let $acc0 = ""
548+            func $f0_1 ($a,$i) =             if (($i >= $s))
549+                then $a
550+                else forEachAssetCalcUnclaimedReward($a, $l[$i])
551+
552+            func $f0_2 ($a,$i) =             if (($i >= $s))
553+                then $a
554+                else throw("List size exceeds 10")
555+
556+            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
557+            }
558+    $Tuple2(nil, dropRight(unclaimedRewardStr, 1))
559+    }
560+
561+
562+
563+@Callable(i)
564+func surfStakingSYSREADONLY (userAddressStrOrEmpty,surfDiff) = {
565+    let surfTotal = getIntOrElse(keyLockParamTotalAmount(), 0)
566+    let gnsbtFromSurfTotal = surfToGnsbt(surfTotal)
567+    if ((userAddressStrOrEmpty == ""))
568+        then $Tuple2(nil, [0, surfTotal, 0, gnsbtFromSurfTotal, 0, height, height])
569+        else {
570+            let userAddress = toAddressOrFail(userAddressStrOrEmpty)
571+            let mergedData = mergeStake(userAddress, surfDiff)
572+            let isNewUser = mergedData._1
573+            let stakedAmount = mergedData._2
574+            let vpEffectiveHeight = mergedData._3
575+            let stakedAmountNEW = mergedData._4
576+            let vpEffectiveHeightNEW = mergedData._5
577+            let surfUser = stakedAmount
578+            let gnsbtFromSurfUser = surfToGnsbt(surfUser)
579+            $Tuple2(nil, [surfUser, surfTotal, gnsbtFromSurfUser, gnsbtFromSurfTotal, vpEffectiveHeight, vpEffectiveHeightNEW])
580+            }
581+    }
582+
583+
584+
585+@Callable(i)
586+func gnsbtFromSurfSYSREADONLY (surfAmt) = $Tuple2(nil, surfToGnsbt(surfAmt))
587+
588+
589+
590+@Callable(i)
591+func configSYSREADONLY () = {
592+    let minLockAmt = getIntegerValue(keyMinLockAmount())
593+    let surfVotingPowerRestrictivePeriod = (1440 * 14)
594+    let brToStartSurfTransformation = 1150000
595+    $Tuple2(nil, [minLockAmt, (gnsbtFromSurfCoeff * MULT6), surfVotingPowerRestrictivePeriod, brToStartSurfTransformation])
596+    }
597+
598+
github/deemru/w8io/6500d08 
35.08 ms ◑