tx · 9U1BrvMcfzZY2mTbNvYVAvLZc93n5EGrTkjMygeNmnWE

3Mp5kisFrqESzrXxAMEPk2k69zpeF41czEE:  -0.01400000 Waves

2021.12.15 15:08 [1835357] smart account 3Mp5kisFrqESzrXxAMEPk2k69zpeF41czEE > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9U1BrvMcfzZY2mTbNvYVAvLZc93n5EGrTkjMygeNmnWE",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1639570178064,
    "version": 1,
    "sender": "3Mp5kisFrqESzrXxAMEPk2k69zpeF41czEE",
    "senderPublicKey": "G349Uq3FTox7dRNLeAfAQeoACvwZ9iEnVSaHcEYn6j8J",
    "proofs": [
        "67k9Q97PLMGNtcUs9azkSxnqJ8aCRKAvfVS1HNkPgWxgdicQsBso3yPCFSLgeGqr2APCNvRPHHz7SwtCSZPNFZ6f"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1835357,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Bd97XfqCjXkdwgEN6zEz38he466iZ9NoiPUwRovUANVN
Next: BcM2YkLT9CAJtvtavJSGYTDTzgapKXtVXN4tB7D29onc

Diff: 
Old
New
Differences
44
44
 
45
45
 
46
46
 
func formatConfig (wxAssetIdStr,matcherPacemakerAddressStr,boostingContractAddressStr,maxDepth) = makeString(["%s%s%s%d", wxAssetIdStr, matcherPacemakerAddressStr, boostingContractAddressStr, toString(maxDepth)], SEP)
47
+
48
+
49
+
func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
47
50
 
48
51
 
49
52
 
func keyUsersCount () = "%s__nextUserNum"
237
240
 
    let latestPeriod = getNumberByKey(keyNextProcessedPeriod())
238
241
 
    let totalWeight = getNumberByKey(keyTotalWeightForPeriod(currentPeriod))
239
242
 
    let heightForPeriod = getNumberByKey(keyHeightForPeriod(currentPeriod))
240
-
    let $t01103911151 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, currentUser)
241
-
    let userWeight = $t01103911151._1
242
-
    let ignored = $t01103911151._2
243
+
    let $t01112411236 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, currentUser)
244
+
    let userWeight = $t01112411236._1
245
+
    let ignored = $t01112411236._2
243
246
 
    let userAmountForPeriod = fraction(getNumberByKey(keyTotalAmountForPeriod(currentPeriod)), userWeight, totalWeight)
244
247
 
    if (if ((0 >= depth))
245
248
 
        then true
258
261
 
        then throw("Nothing to claim")
259
262
 
        else {
260
263
 
            let boostingContract = fromBase58String(cfgArray[IdxCfgBoostingContract])
261
-
            let $t01207212164 = claimInternal(boostingContract, currentPeriod, userIdx, USERDEPTH, 0)
262
-
            let period = $t01207212164._1
263
-
            let amount = $t01207212164._2
264
+
            let $t01215712249 = claimInternal(boostingContract, currentPeriod, userIdx, USERDEPTH, 0)
265
+
            let period = $t01215712249._1
266
+
            let amount = $t01215712249._2
264
267
 
            $Tuple5(period, amount, userIdx, cfgArray, latestPeriod)
265
268
 
            }
266
269
 
    }
329
332
 
@Callable(i)
330
333
 
func claimReward () = {
331
334
 
    let address = toString(i.caller)
332
-
    let $t01510415186 = commonClaimReward(address)
333
-
    let period = $t01510415186._1
334
-
    let amount = $t01510415186._2
335
-
    let userIdx = $t01510415186._3
336
-
    let cfgArray = $t01510415186._4
337
-
    let latestPeriod = $t01510415186._5
335
+
    let $t01518915271 = commonClaimReward(address)
336
+
    let period = $t01518915271._1
337
+
    let amount = $t01518915271._2
338
+
    let userIdx = $t01518915271._3
339
+
    let cfgArray = $t01518915271._4
340
+
    let latestPeriod = $t01518915271._5
338
341
 
    $Tuple2([IntegerEntry(keyNextUnlaimedPeriodOfUser(userIdx), period), ScriptTransfer(i.caller, amount, fromBase58String(cfgArray[IdxCfgAssetId])), HistoryEntry("claim", address, amount, period, latestPeriod, i)], amount)
339
342
 
    }
340
343
 
385
388
 
@Callable(i)
386
389
 
func onEmissionForGwxStart () = if ((i.caller != factoryContract))
387
390
 
    then throw("permissions denied")
388
-
    else [IntegerEntry("%s%s__gwxRewardEmissionPart__startHeight", height)]
391
+
    else [IntegerEntry(keyGwxRewardEmissionStartHeight(), height)]
389
392
 
390
393
 

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

github/deemru/w8io/169f3d6 
56.03 ms ◑