tx · 88skCY7WSPBf2kBxcBEfBtCWzUycHbK1A6qTsj6gRotD

3ND3h8eJzLtBXdpZCE73WT3YDxGzAJxDcMg:  -0.01000000 Waves

2021.11.22 14:12 [1802151] smart account 3ND3h8eJzLtBXdpZCE73WT3YDxGzAJxDcMg > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "88skCY7WSPBf2kBxcBEfBtCWzUycHbK1A6qTsj6gRotD",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1637579571687,
    "version": 1,
    "sender": "3ND3h8eJzLtBXdpZCE73WT3YDxGzAJxDcMg",
    "senderPublicKey": "JA5VRFRNihwh3DqqBD3tnuDSDcDbQf74Td7zJdr8DgUo",
    "proofs": [
        "59scjTRqbHfoV2pysgBxQvRLmfsJztfVnmwaJBRYTc5rRQJLWSDahf13KSsvQsJ9geJkUKHcXtNnTKAXciNtFr2m"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1802151,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: AJ529axcnzTGkpYovTz1Qrc7aDhzavFTWxSHscQR7niV

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let revisionNum = ""
5+
6+let SEP = "__"
7+
8+let MAXDEPTH = 17
9+
10+let USERDEPTH = 26
11+
12+let SCALE = 1000
13+
14+func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
15+
16+
17+func getStringByKey (key) = valueOrElse(getString(this, key), "")
18+
19+
20+func getStringOrFail (key) = valueOrErrorMessage(getString(key), (("mandatory this." + key) + " is not defined"))
21+
22+
23+let IdxCfgAssetId = 1
24+
25+let IdxCfgPacemakerAddress = 2
26+
27+let IdxCfgBoostingContract = 3
28+
29+let IdxCfgMaxDepth = 4
30+
31+func keyConfig () = "%s__config"
32+
33+
34+func readConfigArrayOrFail () = split(getStringOrFail(keyConfig()), SEP)
35+
36+
37+func formatConfig (wxAssetIdStr,matcherPacemakerAddressStr,boostingContractAddressStr,maxDepth) = makeString(["%s%s%s%d", wxAssetIdStr, matcherPacemakerAddressStr, boostingContractAddressStr, toString(maxDepth)], SEP)
38+
39+
40+func keyUsersCount () = "%s__nextUserNum"
41+
42+
43+func keyNextProcessedUser () = "%s__nextProcessedUser"
44+
45+
46+func keyLatestPeriod () = "%s__latestPeriod"
47+
48+
49+func keyNextPeriod () = "%s__nextPeriod"
50+
51+
52+func keyNextProcessedPeriod () = "%s__nextProcessedPeriod"
53+
54+
55+func keyNextUnlaimedPeriodOfUser (userIndex) = makeString(["%s%d__nextClaimedPeriod", toString(userIndex)], SEP)
56+
57+
58+func keyLastProcessedPeriodOfUser (userIndex) = makeString(["%s%d__lastProcessedPeriod", toString(userIndex)], SEP)
59+
60+
61+func keyHeightForPeriod (period) = makeString(["%s%d__startHeightForPeriod", toString(period)], SEP)
62+
63+
64+func keyTotalAmountForPeriod (period) = makeString(["%s%d__totalAmountForPeriod", toString(period)], SEP)
65+
66+
67+func keyTotalWeightForPeriod (period) = makeString(["%s%d__totalWeightForPeriod", toString(period)], SEP)
68+
69+
70+func keyUserKValueForPeriod (period,userIndex) = makeString(["%s%d%s%d__paramByPeriod", toString(userIndex), "k", toString(period)], SEP)
71+
72+
73+func keyUserBValueForPeriod (period,userIndex) = makeString(["%s%d%s%d__paramByPeriod", toString(userIndex), "b", toString(period)], SEP)
74+
75+
76+func HistoryEntry (type,user,amount,currentPeriod,latestPeriod,i) = {
77+    let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
78+    let historyDATA = makeString(["%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(currentPeriod), toString(latestPeriod)], SEP)
79+    StringEntry(historyKEY, historyDATA)
80+    }
81+
82+
83+func calcUserWeight (boostingContractAddress,heightForPeriod,period,userIndex) = {
84+    let kLast = keyLastProcessedPeriodOfUser(userIndex)
85+    let kKey = keyUserKValueForPeriod(period, userIndex)
86+    let kRaw = getInteger(boostingContractAddress, kKey)
87+    if (isDefined(kRaw))
88+        then {
89+            let k = value(kRaw)
90+            let b = value(getInteger(boostingContractAddress, keyUserBValueForPeriod(period, userIndex)))
91+            let w = ((k * heightForPeriod) + b)
92+            if ((w > 0))
93+                then $Tuple2((w / SCALE), [IntegerEntry(kLast, period)])
94+                else $Tuple2(0, nil)
95+            }
96+        else {
97+            let p = getInteger(this, kLast)
98+            if (isDefined(p))
99+                then {
100+                    let pv = value(p)
101+                    let k = value(getInteger(boostingContractAddress, keyUserKValueForPeriod(pv, userIndex)))
102+                    let b = value(getInteger(boostingContractAddress, keyUserBValueForPeriod(pv, userIndex)))
103+                    let w = ((k * heightForPeriod) + b)
104+                    if ((w > 0))
105+                        then $Tuple2((w / SCALE), nil)
106+                        else $Tuple2(0, nil)
107+                    }
108+                else $Tuple2(0, nil)
109+            }
110+    }
111+
112+
113+func getUserIndexByAddress (boostingContractAddressStr,userAddress) = {
114+    let key = makeString(["%s%s%s", "mapping", "user2num", userAddress], SEP)
115+    parseIntValue(valueOrErrorMessage(getString(Address(fromBase58String(boostingContractAddressStr)), key), ((("User address " + userAddress) + " is not found in boosting contract data, key=") + key)))
116+    }
117+
118+
119+func nextPeriod () = getNumberByKey(keyNextPeriod())
120+
121+
122+func invokeProcess (boostingContract,period,user,depth,weight) = {
123+    let result = invoke(this, "processNextBatch", [boostingContract, period, user, depth, weight], nil)
124+    if ((result == result))
125+        then         match result {
126+            case r: (Int, Int, Int) => 
127+                r
128+            case _ => 
129+                throw("Incorrect invoke result")
130+        }
131+        else throw("Strict value is not equal to itself.")
132+    }
133+
134+
135+func checkLastPartOfPeriod (boostingContract,currentPeriod,latestPeriod,depth,totalWeightKey,weight) = if ((latestPeriod >= (currentPeriod + 1)))
136+    then invokeProcess(boostingContract, (currentPeriod + 1), 0, (depth - 1), 0)
137+    else $Tuple3((currentPeriod + 1), 0, 0)
138+
139+
140+func processNextBatchInternal (boostingContract,currentPeriod,currentUser,depth,totalWeight) = {
141+    let boostingContractAddress = Address(boostingContract)
142+    let latestPeriod = getNumberByKey(keyLatestPeriod())
143+    let usersCount = valueOrElse(getInteger(boostingContractAddress, keyUsersCount()), 0)
144+    let totalWeightKey = keyTotalWeightForPeriod(currentPeriod)
145+    let heightForPeriod = getNumberByKey(keyHeightForPeriod(currentPeriod))
146+    if (if ((depth > 0))
147+        then (latestPeriod >= currentPeriod)
148+        else false)
149+        then {
150+            let t0 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, currentUser)
151+            let weight0 = (totalWeight + t0._1)
152+            if ((usersCount > (currentUser + 1)))
153+                then {
154+                    let t1 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 1))
155+                    let weight1 = (weight0 + t1._1)
156+                    if ((usersCount > (currentUser + 2)))
157+                        then {
158+                            let t2 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 2))
159+                            let weight2 = (weight1 + t2._1)
160+                            if ((usersCount > (currentUser + 3)))
161+                                then {
162+                                    let t3 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 3))
163+                                    let weight3 = (weight2 + t3._1)
164+                                    if ((usersCount > (currentUser + 4)))
165+                                        then {
166+                                            let t4 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 4))
167+                                            let weight4 = (weight3 + t4._1)
168+                                            if ((usersCount > (currentUser + 5)))
169+                                                then {
170+                                                    let t5 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 5))
171+                                                    let weight5 = (weight4 + t5._1)
172+                                                    if ((usersCount > (currentUser + 6)))
173+                                                        then {
174+                                                            let r5 = invokeProcess(boostingContract, currentPeriod, (currentUser + 6), (depth - 1), weight5)
175+                                                            $Tuple4((((((t0._2 ++ t1._2) ++ t2._2) ++ t3._2) ++ t4._2) ++ t5._2), r5._1, r5._2, r5._3)
176+                                                            }
177+                                                        else {
178+                                                            let r5 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight5)
179+                                                            $Tuple4((((((([IntegerEntry(totalWeightKey, weight5)] ++ t0._2) ++ t1._2) ++ t2._2) ++ t3._2) ++ t4._2) ++ t5._2), r5._1, r5._2, r5._3)
180+                                                            }
181+                                                    }
182+                                                else {
183+                                                    let r4 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight4)
184+                                                    $Tuple4(((((([IntegerEntry(totalWeightKey, weight4)] ++ t0._2) ++ t1._2) ++ t2._2) ++ t3._2) ++ t4._2), r4._1, r4._2, r4._3)
185+                                                    }
186+                                            }
187+                                        else {
188+                                            let r3 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight3)
189+                                            $Tuple4((((([IntegerEntry(totalWeightKey, weight3)] ++ t0._2) ++ t1._2) ++ t2._2) ++ t3._2), r3._1, r3._2, r3._3)
190+                                            }
191+                                    }
192+                                else {
193+                                    let r2 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight2)
194+                                    $Tuple4(((([IntegerEntry(totalWeightKey, weight2)] ++ t0._2) ++ t1._2) ++ t2._2), r2._1, r2._2, r2._3)
195+                                    }
196+                            }
197+                        else {
198+                            let r1 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight1)
199+                            $Tuple4((([IntegerEntry(totalWeightKey, weight1)] ++ t0._2) ++ t1._2), r1._1, r1._2, r1._3)
200+                            }
201+                    }
202+                else {
203+                    let r0 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight0)
204+                    $Tuple4(([IntegerEntry(totalWeightKey, weight0)] ++ t0._2), r0._1, r0._2, r0._3)
205+                    }
206+            }
207+        else if ((currentUser == 0))
208+            then $Tuple4(nil, currentPeriod, 0, 0)
209+            else $Tuple4([IntegerEntry(totalWeightKey, totalWeight)], currentPeriod, currentUser, 0)
210+    }
211+
212+
213+func invokeClaim (boostingContract,period,user,depth,total) = {
214+    let result = invoke(this, "claimNextBatch", [boostingContract, period, user, depth, total], nil)
215+    if ((result == result))
216+        then         match result {
217+            case r: (Int, Int) => 
218+                r
219+            case _ => 
220+                throw("Incorrect invoke result")
221+        }
222+        else throw("Strict value is not equal to itself.")
223+    }
224+
225+
226+func claimInternal (boostingContract,currentPeriod,currentUser,depth,userAccumulated) = {
227+    let boostingContractAddress = Address(boostingContract)
228+    let latestPeriod = getNumberByKey(keyNextProcessedPeriod())
229+    let totalWeight = getNumberByKey(keyTotalWeightForPeriod(currentPeriod))
230+    let heightForPeriod = getNumberByKey(keyHeightForPeriod(currentPeriod))
231+    let $t01069910811 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, currentUser)
232+    let userWeight = $t01069910811._1
233+    let ignored = $t01069910811._2
234+    let userAmountForPeriod = fraction(getNumberByKey(keyTotalAmountForPeriod(currentPeriod)), userWeight, totalWeight)
235+    if (if ((0 >= depth))
236+        then true
237+        else ((currentPeriod + 1) >= latestPeriod))
238+        then $Tuple2((currentPeriod + 1), (userAccumulated + userAmountForPeriod))
239+        else invokeClaim(boostingContract, (currentPeriod + 1), currentUser, (depth - 1), (userAccumulated + userAmountForPeriod))
240+    }
241+
242+
243+@Callable(i)
244+func processNextBatch (boostingContract,currentPeriod,currentUser,depth,totalWeight) = if ((i.caller != this))
245+    then throw("Should be called by this script only")
246+    else {
247+        let tpl = processNextBatchInternal(boostingContract, currentPeriod, currentUser, depth, totalWeight)
248+        $Tuple2(tpl._1, $Tuple3(tpl._2, tpl._3, tpl._4))
249+        }
250+
251+
252+
253+@Callable(i)
254+func processPendingPeriodsAndUsers () = {
255+    let currentPeriod = getNumberByKey(keyNextProcessedPeriod())
256+    if ((currentPeriod > getNumberByKey(keyLatestPeriod())))
257+        then throw("Nothing to process")
258+        else {
259+            let cfgArray = readConfigArrayOrFail()
260+            let depth = parseIntValue(cfgArray[IdxCfgMaxDepth])
261+            if ((depth > MAXDEPTH))
262+                then throw("Depth exceeds MAXDEPTH")
263+                else {
264+                    let boostingContract = fromBase58String(cfgArray[IdxCfgBoostingContract])
265+                    let currentUser = getNumberByKey(keyNextProcessedUser())
266+                    let totalWeight = getNumberByKey(keyTotalWeightForPeriod(currentPeriod))
267+                    let r = processNextBatchInternal(boostingContract, currentPeriod, currentUser, depth, totalWeight)
268+                    ((r._1 :+ IntegerEntry(keyNextProcessedPeriod(), r._2)) :+ IntegerEntry(keyNextProcessedUser(), r._3))
269+                    }
270+            }
271+    }
272+
273+
274+
275+@Callable(i)
276+func deposit () = {
277+    let cfgArray = readConfigArrayOrFail()
278+    if ((i.caller != Address(fromBase58String(cfgArray[IdxCfgPacemakerAddress]))))
279+        then throw("Wrong caller address")
280+        else {
281+            let assetId = value(value(i.payments[0]).assetId)
282+            if ((assetId != fromBase58String(cfgArray[IdxCfgAssetId])))
283+                then throw("Wrong payment asset")
284+                else {
285+                    let period = nextPeriod()
286+[IntegerEntry(keyLatestPeriod(), period), IntegerEntry(keyHeightForPeriod(period), height), IntegerEntry(keyTotalAmountForPeriod(period), value(i.payments[0]).amount), IntegerEntry(keyNextPeriod(), (period + 1))]
287+                    }
288+            }
289+    }
290+
291+
292+
293+@Callable(i)
294+func claimNextBatch (boostingContract,currentPeriod,currentUser,depth,totalWeight) = if ((i.caller != this))
295+    then throw("Should be called by this script only")
296+    else {
297+        let periodAndTotal = claimInternal(boostingContract, currentPeriod, currentUser, depth, totalWeight)
298+        $Tuple2(nil, periodAndTotal)
299+        }
300+
301+
302+
303+@Callable(i)
304+func claimReward () = {
305+    let cfgArray = readConfigArrayOrFail()
306+    let address = toString(i.caller)
307+    let userIdx = getUserIndexByAddress(cfgArray[IdxCfgBoostingContract], address)
308+    let currentPeriod = getNumberByKey(keyNextUnlaimedPeriodOfUser(userIdx))
309+    let latestPeriod = getNumberByKey(keyNextProcessedPeriod())
310+    if ((currentPeriod >= latestPeriod))
311+        then throw("Nothing to claim")
312+        else {
313+            let boostingContract = fromBase58String(cfgArray[IdxCfgBoostingContract])
314+            let $t01456214654 = claimInternal(boostingContract, currentPeriod, userIdx, USERDEPTH, 0)
315+            let period = $t01456214654._1
316+            let amount = $t01456214654._2
317+            $Tuple2([IntegerEntry(keyNextUnlaimedPeriodOfUser(userIdx), period), ScriptTransfer(i.caller, amount, fromBase58String(cfgArray[IdxCfgAssetId])), HistoryEntry("claim", address, amount, period, latestPeriod, i)], amount)
318+            }
319+    }
320+
321+
322+
323+@Callable(i)
324+func calcGwxParamsREADONLY (wxAmount,lockStartHeight,lockDurationBlocks) = {
325+    let lockEndHeight = (lockStartHeight + lockDurationBlocks)
326+    let scale8ParamK = -(fraction(wxAmount, SCALE, lockDurationBlocks))
327+    let scale8ParamB = (fraction(wxAmount, SCALE, lockDurationBlocks) * lockEndHeight)
328+    $Tuple2(nil, [scale8ParamK, scale8ParamB, nextPeriod()])
329+    }
330+
331+
332+
333+@Callable(i)
334+func constructor (wxAssetIdStr,matcherPacemakerAddressStr,boostingContractAddressStr,maxDepth) = if ((this != i.caller))
335+    then throw("not authorized")
336+    else [StringEntry(keyConfig(), formatConfig(wxAssetIdStr, matcherPacemakerAddressStr, boostingContractAddressStr, maxDepth))]
337+
338+
github/deemru/w8io/3ef1775 
50.39 ms ◑