tx · AJ529axcnzTGkpYovTz1Qrc7aDhzavFTWxSHscQR7niV

3ND3h8eJzLtBXdpZCE73WT3YDxGzAJxDcMg:  -0.01000000 Waves

2021.11.22 14:19 [1802160] smart account 3ND3h8eJzLtBXdpZCE73WT3YDxGzAJxDcMg > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 88skCY7WSPBf2kBxcBEfBtCWzUycHbK1A6qTsj6gRotD
Next: none

Diff: 
Old
New
Differences
240
240
 
    }
241
241
 
242
242
 
243
+
func commonClaimReward (userAddress) = {
244
+
    let cfgArray = readConfigArrayOrFail()
245
+
    let userIdx = getUserIndexByAddress(cfgArray[IdxCfgBoostingContract], userAddress)
246
+
    let currentPeriod = getNumberByKey(keyNextUnlaimedPeriodOfUser(userIdx))
247
+
    let latestPeriod = getNumberByKey(keyNextProcessedPeriod())
248
+
    if ((currentPeriod >= latestPeriod))
249
+
        then throw("Nothing to claim")
250
+
        else {
251
+
            let boostingContract = fromBase58String(cfgArray[IdxCfgBoostingContract])
252
+
            let $t01173211824 = claimInternal(boostingContract, currentPeriod, userIdx, USERDEPTH, 0)
253
+
            let period = $t01173211824._1
254
+
            let amount = $t01173211824._2
255
+
            $Tuple5(period, amount, userIdx, cfgArray, latestPeriod)
256
+
            }
257
+
    }
258
+
259
+
243
260
 
@Callable(i)
244
261
 
func processNextBatch (boostingContract,currentPeriod,currentUser,depth,totalWeight) = if ((i.caller != this))
245
262
 
    then throw("Should be called by this script only")
302
319
 
303
320
 
@Callable(i)
304
321
 
func claimReward () = {
305
-
    let cfgArray = readConfigArrayOrFail()
306
322
 
    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
-
            }
323
+
    let $t01476414846 = commonClaimReward(address)
324
+
    let period = $t01476414846._1
325
+
    let amount = $t01476414846._2
326
+
    let userIdx = $t01476414846._3
327
+
    let cfgArray = $t01476414846._4
328
+
    let latestPeriod = $t01476414846._5
329
+
    $Tuple2([IntegerEntry(keyNextUnlaimedPeriodOfUser(userIdx), period), ScriptTransfer(i.caller, amount, fromBase58String(cfgArray[IdxCfgAssetId])), HistoryEntry("claim", address, amount, period, latestPeriod, i)], amount)
330
+
    }
331
+
332
+
333
+
334
+
@Callable(i)
335
+
func claimRewardREADONLY (address) = {
336
+
    let claimResults = commonClaimReward(address)
337
+
    let amount = claimResults._2
338
+
    $Tuple2(nil, amount)
319
339
 
    }
320
340
 
321
341
 

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

github/deemru/w8io/3ef1775 
1097.28 ms ◑