tx · Fxy6e2QGkatqZU7QT6sx8HAKTopY12XGXkVVoVtvm2Lm

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.02400000 Waves

2023.04.06 18:04 [2522859] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Fxy6e2QGkatqZU7QT6sx8HAKTopY12XGXkVVoVtvm2Lm",
    "fee": 2400000,
    "feeAssetId": null,
    "timestamp": 1680793474750,
    "version": 2,
    "chainId": 84,
    "sender": "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz",
    "senderPublicKey": "D28XoueZWsMfm8Y5pa6C5ZFuYoWgre2Wm8tzJANJgMnq",
    "proofs": [
        "3bfEeCnhtPywUCpXTg9MbBFvFzDHPvUqTBcFijTy86xDjmq7gdR8SJuF76YRuiPTZ93zr9TWbytD8EqBFCQiMJSq"
    ],
    "script": "base64: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",
    "height": 2522859,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EbsRBQWZa8sJRpSdEuAtvhhzAdcEMshah6YSyeDUYVwo
Next: Djz7ee27LvVChWjoBCadUpWCKSCUBWaybYSjtGtfcEVH

Diff: 
Old
New
Differences
766
766
 
767
767
 
768
768
 
@Callable(i)
769
+
func stakedTotalREADONLY (lpAssetIdStr) = {
770
+
    let stakedTotal = valueOrElse(getInteger(keyStakedTotal(lpAssetIdStr)), 0)
771
+
    $Tuple2(nil, stakedTotal)
772
+
    }
773
+
774
+
775
+
776
+
@Callable(i)
769
777
 
func usersListTraversal (lpAssetId) = {
770
778
 
    let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
771
779
 
        then true
820
828
 
func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
821
829
 
    then throwErr("permissions denied")
822
830
 
    else {
823
-
        let $t03321333323 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
824
-
        let wxPerLpIntegralNew = $t03321333323._1
825
-
        let poolIntegralSTATE = $t03321333323._2
826
-
        let poolDEBUG = $t03321333323._3
831
+
        let $t03337933489 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
832
+
        let wxPerLpIntegralNew = $t03337933489._1
833
+
        let poolIntegralSTATE = $t03337933489._2
834
+
        let poolDEBUG = $t03337933489._3
827
835
 
        poolIntegralSTATE
828
836
 
        }
829
837
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SCALE8 = 8
5
5
 
6
6
 
let MULT3 = 1000
7
7
 
8
8
 
let MULT8 = 100000000
9
9
 
10
10
 
let SCALE18 = 18
11
11
 
12
12
 
let MULT18 = toBigInt(1000000000000000000)
13
13
 
14
14
 
let SEP = "__"
15
15
 
16
16
 
let POOLWEIGHTMULT = MULT8
17
17
 
18
18
 
let zeroBigInt = toBigInt(0)
19
19
 
20
20
 
let oneBigInt = toBigInt(1)
21
21
 
22
22
 
func wrapErr (msg) = makeString(["staking.ride:", toString(this), msg], " ")
23
23
 
24
24
 
25
25
 
func throwErr (msg) = throw(wrapErr(msg))
26
26
 
27
27
 
28
28
 
func asAnyList (val) = match val {
29
29
 
    case valAnyLyst: List[Any] => 
30
30
 
        valAnyLyst
31
31
 
    case _ => 
32
32
 
        throwErr("fail to cast into List[Any]")
33
33
 
}
34
34
 
35
35
 
36
36
 
func asInt (val) = match val {
37
37
 
    case valInt: Int => 
38
38
 
        valInt
39
39
 
    case _ => 
40
40
 
        throwErr("fail to cast into Int")
41
41
 
}
42
42
 
43
43
 
44
44
 
func asString (val) = match val {
45
45
 
    case valStr: String => 
46
46
 
        valStr
47
47
 
    case _ => 
48
48
 
        throwErr("fail to cast into Int")
49
49
 
}
50
50
 
51
51
 
52
52
 
func asByteVector (val) = match val {
53
53
 
    case valBin: ByteVector => 
54
54
 
        valBin
55
55
 
    case _ => 
56
56
 
        throwErr("fail to cast into Int")
57
57
 
}
58
58
 
59
59
 
60
60
 
func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
61
61
 
62
62
 
63
63
 
func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
64
64
 
65
65
 
66
66
 
func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
67
67
 
68
68
 
69
69
 
func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
70
70
 
71
71
 
72
72
 
func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
73
73
 
74
74
 
75
75
 
func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
76
76
 
77
77
 
78
78
 
func getBigIntFromStringOrDefault (address,key,defaultVal) = match getString(address, key) {
79
79
 
    case s: String => 
80
80
 
        value(parseBigInt(s))
81
81
 
    case _: Unit => 
82
82
 
        defaultVal
83
83
 
    case _ => 
84
84
 
        throw("Match error")
85
85
 
}
86
86
 
87
87
 
88
88
 
func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), MULT18, toBigInt(origScaleMult))
89
89
 
90
90
 
91
91
 
func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), MULT18))
92
92
 
93
93
 
94
94
 
func keyFactoryAddress () = "%s%s__config__factoryAddress"
95
95
 
96
96
 
97
97
 
func keyVotingEmissionContract () = "%s__votingEmissionContract"
98
98
 
99
99
 
100
100
 
let IdxFactoryCfgStakingDapp = 1
101
101
 
102
102
 
let IdxFactoryCfgBoostingDapp = 2
103
103
 
104
104
 
let IdxFactoryCfgIdoDapp = 3
105
105
 
106
106
 
let IdxFactoryCfgTeamDapp = 4
107
107
 
108
108
 
let IdxFactoryCfgEmissionDapp = 5
109
109
 
110
110
 
let IdxFactoryCfgRestDapp = 6
111
111
 
112
112
 
let IdxFactoryCfgSlippageDapp = 7
113
113
 
114
114
 
func keyFactoryCfg () = "%s__factoryConfig"
115
115
 
116
116
 
117
117
 
func keyManagerPublicKey () = "%s__managerPublicKey"
118
118
 
119
119
 
120
120
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
121
121
 
122
122
 
123
123
 
func keyStablePoolAddonAddr () = "%s__stablePoolAddonAddr"
124
124
 
125
125
 
126
126
 
func keyAddonAddr () = "%s__addonAddr"
127
127
 
128
128
 
129
129
 
func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
130
130
 
131
131
 
132
132
 
func keyFactoryLpList () = "%s__lpTokensList"
133
133
 
134
134
 
135
135
 
func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
136
136
 
137
137
 
138
138
 
func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
139
139
 
140
140
 
141
141
 
func readLpList (factory) = split(valueOrElse(getString(factory, keyFactoryLpList()), ""), SEP)
142
142
 
143
143
 
144
144
 
func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
145
145
 
146
146
 
147
147
 
func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
148
148
 
149
149
 
150
150
 
func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
151
151
 
152
152
 
153
153
 
func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
154
154
 
155
155
 
156
156
 
func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
157
157
 
158
158
 
159
159
 
func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
160
160
 
161
161
 
162
162
 
func keyEmissionStartBlock () = "%s%s__emission__startBlock"
163
163
 
164
164
 
165
165
 
func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
166
166
 
167
167
 
168
168
 
func keyEmissionEndBlock () = "%s%s__emission__endBlock"
169
169
 
170
170
 
171
171
 
func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
172
172
 
173
173
 
174
174
 
func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
175
175
 
176
176
 
177
177
 
func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
178
178
 
179
179
 
180
180
 
func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
181
181
 
182
182
 
183
183
 
func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
184
184
 
185
185
 
186
186
 
func keyClaimedTotal (lpAssetIdStr) = makeString(["%s%s%s__claimed__total", lpAssetIdStr], SEP)
187
187
 
188
188
 
189
189
 
func readStaked (key) = valueOrElse(getInteger(this, key), 0)
190
190
 
191
191
 
192
192
 
func keyLastTotalLpBalance (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "bal"], SEP)
193
193
 
194
194
 
195
195
 
func keyLastUserLpBalance (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "bal"], SEP)
196
196
 
197
197
 
198
198
 
func keyTotalLpBalanceIntegral (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "balINT"], SEP)
199
199
 
200
200
 
201
201
 
func keyUserLpBalanceIntegral (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "balINT"], SEP)
202
202
 
203
203
 
204
204
 
func keyTotalLpBalanceIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "lastUpd"], SEP)
205
205
 
206
206
 
207
207
 
func keyUserLpBalanceIntegralLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "lastUpd"], SEP)
208
208
 
209
209
 
210
210
 
func keyWxPerLpIntegral (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpInt"], SEP)
211
211
 
212
212
 
213
213
 
func keyWxPerLpIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpIntH"], SEP)
214
214
 
215
215
 
216
216
 
func keyWxToClaimUser (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpInt"], SEP)
217
217
 
218
218
 
219
219
 
func keyWxPerLpIntegralUserLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpIntH"], SEP)
220
220
 
221
221
 
222
222
 
func keyWxPerLp (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLp"], SEP)
223
223
 
224
224
 
225
225
 
func keyWxPerLpX18 (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLpX18"], SEP)
226
226
 
227
227
 
228
228
 
func keyWxPerLpIntegralUserLast (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "uIntL"], SEP)
229
229
 
230
230
 
231
231
 
func keyOperationHistoryRecord (type,userAddress,txId58) = makeString(["%s%s%s%s__history", type, userAddress, txId58], SEP)
232
232
 
233
233
 
234
234
 
func formatHistoryRecord (userAddress,lpAssetId,type,amount) = makeString(["%s%s%s%d%d%d", userAddress, lpAssetId, type, toString(height), toString(lastBlock.timestamp), toString(amount)], SEP)
235
235
 
236
236
 
237
237
 
func OperationHistoryEntry (type,userAddress,lpAssetId,amount,txId) = StringEntry(keyOperationHistoryRecord(type, userAddress, toBase58String(txId)), formatHistoryRecord(userAddress, lpAssetId, type, amount))
238
238
 
239
239
 
240
240
 
let factoryAddress = getStringOrFail(this, keyFactoryAddress())
241
241
 
242
242
 
let factoryContract = addressFromStringValue(factoryAddress)
243
243
 
244
244
 
let factoryCfg = readFactoryCfgOrFail(factoryContract)
245
245
 
246
246
 
let emissionContract = getEmissionAddressOrFail(factoryCfg)
247
247
 
248
248
 
let boostingContract = getBoostingAddressOrFail(factoryCfg)
249
249
 
250
250
 
let boostCoeff = {
251
251
 
    let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
252
252
 
    if ($isInstanceOf(@, "Int"))
253
253
 
        then @
254
254
 
        else throw(($getType(@) + " couldn't be cast to Int"))
255
255
 
    }
256
256
 
257
257
 
let lpStakingPoolsContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(makeString(["%s", "lpStakingPoolsContract"], SEP)), wrapErr("lp_staking_pools contract address is undefined"))), wrapErr("invalid lp_staking_pools contract address"))
258
258
 
259
259
 
func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
260
260
 
261
261
 
262
262
 
func getUsersListName (lpAssetId) = makeString(["users", lpAssetId], SEP)
263
263
 
264
264
 
265
265
 
func keyListHead (listName) = makeString(["%s%s%s", listName, "head"], SEP)
266
266
 
267
267
 
268
268
 
func keyListSize (listName) = makeString(["%s%s%s", listName, "size"], SEP)
269
269
 
270
270
 
271
271
 
func keyListPrev (listName,id) = makeString(["%s%s%s%s", listName, id, "prev"], SEP)
272
272
 
273
273
 
274
274
 
func keyListNext (listName,id) = makeString(["%s%s%s%s", listName, id, "next"], SEP)
275
275
 
276
276
 
277
277
 
func containsNode (listName,id) = {
278
278
 
    let headOrUnit = getString(this, keyListHead(listName))
279
279
 
    let prevOrUnit = getString(this, keyListPrev(listName, id))
280
280
 
    let nextOrUnit = getString(this, keyListNext(listName, id))
281
281
 
    if (if ((id == valueOrElse(headOrUnit, "")))
282
282
 
        then true
283
283
 
        else (prevOrUnit != unit))
284
284
 
        then true
285
285
 
        else (nextOrUnit != unit)
286
286
 
    }
287
287
 
288
288
 
289
289
 
func insertNodeActions (listName,id) = {
290
290
 
    let headOrUnit = getString(this, keyListHead(listName))
291
291
 
    let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
292
292
 
    let checkNode = if (!(containsNode(listName, id)))
293
293
 
        then true
294
294
 
        else throwErr("Node exists")
295
295
 
    if ((checkNode == checkNode))
296
296
 
        then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
297
297
 
            then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
298
298
 
            else nil)) ++ [StringEntry(keyListHead(listName), id)])
299
299
 
        else throw("Strict value is not equal to itself.")
300
300
 
    }
301
301
 
302
302
 
303
303
 
func deleteNodeActions (listName,id) = {
304
304
 
    let headOrUnit = getString(this, keyListHead(listName))
305
305
 
    let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
306
306
 
    let prevOrUnit = getString(this, keyListPrev(listName, id))
307
307
 
    let nextOrUnit = getString(this, keyListNext(listName, id))
308
308
 
    ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
309
309
 
        then (nextOrUnit != unit)
310
310
 
        else false)
311
311
 
        then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
312
312
 
        else if ((nextOrUnit != unit))
313
313
 
            then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
314
314
 
            else if ((prevOrUnit != unit))
315
315
 
                then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
316
316
 
                else if ((id == valueOrElse(headOrUnit, "")))
317
317
 
                    then [DeleteEntry(keyListHead(listName))]
318
318
 
                    else throwErr(((("invalid node: " + listName) + ".") + id))))
319
319
 
    }
320
320
 
321
321
 
322
322
 
func calcWxPerLpIntegralUserLast (stakedByUser,wxPerLpIntegralUserLastUpdHeightOrZero,wxPerLpIntegralNew,wxPerLpIntegralUserLastKEY) = if (if ((wxPerLpIntegralUserLastUpdHeightOrZero == zeroBigInt))
323
323
 
    then (stakedByUser > zeroBigInt)
324
324
 
    else false)
325
325
 
    then zeroBigInt
326
326
 
    else if ((stakedByUser == zeroBigInt))
327
327
 
        then wxPerLpIntegralNew
328
328
 
        else if (if ((wxPerLpIntegralUserLastUpdHeightOrZero > zeroBigInt))
329
329
 
            then (stakedByUser > zeroBigInt)
330
330
 
            else false)
331
331
 
            then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
332
332
 
            else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
333
333
 
334
334
 
335
335
 
func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
336
336
 
    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
337
337
 
    let stakedTotal = toBigInt(readStaked(stakedTotalKEY))
338
338
 
    let nonZeroStakedTotal = if ((stakedTotal == zeroBigInt))
339
339
 
        then oneBigInt
340
340
 
        else stakedTotal
341
341
 
    let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
342
342
 
    let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
343
343
 
    let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
344
344
 
    let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
345
345
 
    let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
346
346
 
    let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
347
347
 
    let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
348
348
 
    let wxPerLpIntegralLastUpdHeight = getIntOrDefault(this, wxPerLpIntegralLastUpdHeightKEY, emissionStartBlock)
349
349
 
    let wxPerLpIntegral = getBigIntFromStringOrZero(this, wxPerLpIntegralKEY)
350
350
 
    let wxPerLpOrZeroX3 = 0
351
351
 
    let dh = max([(height - wxPerLpIntegralLastUpdHeight), 0])
352
352
 
    let wxPerLpX3 = if ((wxPerLpOrZeroX3 != 0))
353
353
 
        then toBigInt(wxPerLpOrZeroX3)
354
354
 
        else fraction(toBigInt(poolWxEmissionPerBlockX3), toBigInt(MULT8), nonZeroStakedTotal)
355
355
 
    let stakedTotalNew = (stakedTotal + toBigInt(lpDeltaAmount))
356
356
 
    let nonZeroStakedTotalNew = if ((stakedTotalNew == zeroBigInt))
357
357
 
        then oneBigInt
358
358
 
        else stakedTotalNew
359
359
 
    let wxPerLpIntegralNew = (wxPerLpIntegral + (wxPerLpX3 * toBigInt(dh)))
360
360
 
    let wxPerLpX3New = (toBigInt(poolWxEmissionPerBlockX3) / nonZeroStakedTotalNew)
361
361
 
    let wxPerLpIntegralLastUpdHeightNew = height
362
362
 
    let debug = makeString([toString(wxPerLpIntegralNew), toString(dh), toString(wxPerLpX3), toString(stakedTotal), toString(poolWxEmissionPerBlockX3), toString(wxEmissionPerBlockX3), toString(poolWeight)], "::")
363
363
 
    $Tuple3(wxPerLpIntegralNew, [StringEntry(wxPerLpIntegralKEY, toString(wxPerLpIntegralNew)), IntegerEntry(wxPerLpIntegralLastUpdHeightKEY, wxPerLpIntegralLastUpdHeightNew), StringEntry(wxPerLpKEY, toString(wxPerLpX3New))], debug)
364
364
 
    }
365
365
 
366
366
 
367
367
 
func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
368
368
 
    let $t01481914941 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
369
369
 
    let wxPerLpIntegralNew = $t01481914941._1
370
370
 
    let poolIntegralSTATE = $t01481914941._2
371
371
 
    let poolDEBUG = $t01481914941._3
372
372
 
    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
373
373
 
    let stakedByUser = readStaked(stakedByUserKEY)
374
374
 
    let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
375
375
 
    let wxPerLpIntegralUserLastUpdHeightKEY = keyWxPerLpIntegralUserLastUpdHeight(lpAssetIdStr, userAddressStr)
376
376
 
    let wxPerLpIntegralUserLastKEY = keyWxPerLpIntegralUserLast(lpAssetIdStr, userAddressStr)
377
377
 
    let wxToClaimUser = getBigIntFromStringOrZero(this, wxToClaimUserKEY)
378
378
 
    let wxPerLpIntegralUserLastUpdHeightOrZero = getIntOrZero(this, wxPerLpIntegralUserLastUpdHeightKEY)
379
379
 
    let wxPerLpIntegralUserLast = calcWxPerLpIntegralUserLast(toBigInt(stakedByUser), toBigInt(wxPerLpIntegralUserLastUpdHeightOrZero), wxPerLpIntegralNew, wxPerLpIntegralUserLastKEY)
380
380
 
    let MULT11 = (MULT8 * MULT3)
381
381
 
    let wxToClaimUserNew = max([(wxToClaimUser + fraction((wxPerLpIntegralNew - wxPerLpIntegralUserLast), toBigInt(stakedByUser), toBigInt(MULT11))), zeroBigInt])
382
382
 
    let wxPerLpIntegralUserLastNew = wxPerLpIntegralNew
383
383
 
    let wxPerLpIntegralUserLastUpdHeightNew = height
384
384
 
    let debug = makeString([toString(wxToClaimUser), toString(wxPerLpIntegralUserLast), toString(stakedByUser), poolDEBUG, toString(height)], "::")
385
385
 
    $Tuple3(wxToClaimUserNew, (poolIntegralSTATE ++ [StringEntry(wxToClaimUserKEY, toString(wxToClaimUserNew)), IntegerEntry(wxPerLpIntegralUserLastUpdHeightKEY, wxPerLpIntegralUserLastUpdHeightNew), StringEntry(wxPerLpIntegralUserLastKEY, toString(wxPerLpIntegralUserLastNew))]), debug)
386
386
 
    }
387
387
 
388
388
 
389
389
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
390
390
 
    case s: String => 
391
391
 
        fromBase58String(s)
392
392
 
    case _: Unit => 
393
393
 
        unit
394
394
 
    case _ => 
395
395
 
        throw("Match error")
396
396
 
}
397
397
 
398
398
 
399
399
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
400
400
 
    case s: String => 
401
401
 
        fromBase58String(s)
402
402
 
    case _: Unit => 
403
403
 
        unit
404
404
 
    case _ => 
405
405
 
        throw("Match error")
406
406
 
}
407
407
 
408
408
 
409
409
 
let permissionDeniedError = throwErr("Permission denied")
410
410
 
411
411
 
func mustThis (i) = if ((i.caller == this))
412
412
 
    then true
413
413
 
    else permissionDeniedError
414
414
 
415
415
 
416
416
 
func mustManager (i) = match managerPublicKeyOrUnit() {
417
417
 
    case pk: ByteVector => 
418
418
 
        if ((i.callerPublicKey == pk))
419
419
 
            then true
420
420
 
            else permissionDeniedError
421
421
 
    case _: Unit => 
422
422
 
        if ((i.caller == this))
423
423
 
            then true
424
424
 
            else permissionDeniedError
425
425
 
    case _ => 
426
426
 
        throw("Match error")
427
427
 
}
428
428
 
429
429
 
430
430
 
func stakeActions (i,lpAssetId,poolAddress,userAddress,amount) = {
431
431
 
    let userAddressStr = toString(userAddress)
432
432
 
    let lpAssetIdStr = toBase58String(lpAssetId)
433
433
 
    let poolAddressStr = toString(poolAddress)
434
434
 
    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
435
435
 
    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
436
436
 
    let stakedByUser = readStaked(stakedByUserKEY)
437
437
 
    let refreshStakedVote = if ((stakedByUser == 0))
438
438
 
        then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
439
439
 
        else unit
440
440
 
    if ((refreshStakedVote == refreshStakedVote))
441
441
 
        then {
442
442
 
            let stakedTotal = readStaked(stakedTotalKEY)
443
443
 
            let $t01816018277 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
444
444
 
            let wxToClaimUserNew = $t01816018277._1
445
445
 
            let integralSTATE = $t01816018277._2
446
446
 
            let debug = $t01816018277._3
447
447
 
            let listName = getUsersListName(lpAssetIdStr)
448
448
 
            let listActions = if (containsNode(listName, userAddressStr))
449
449
 
                then nil
450
450
 
                else insertNodeActions(listName, userAddressStr)
451
451
 
            (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
452
452
 
            }
453
453
 
        else throw("Strict value is not equal to itself.")
454
454
 
    }
455
455
 
456
456
 
457
457
 
func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
458
458
 
    let userAddressStr = toString(userAddress)
459
459
 
    let lpAssetIdStr = toBase58String(lpAssetId)
460
460
 
    let poolAddressStr = toString(poolAddress)
461
461
 
    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
462
462
 
    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
463
463
 
    let stakedByUser = readStaked(stakedByUserKEY)
464
464
 
    let stakedTotal = readStaked(stakedTotalKEY)
465
465
 
    let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
466
466
 
    let listName = getUsersListName(lpAssetIdStr)
467
467
 
    let listActions = if (if (containsNode(listName, userAddressStr))
468
468
 
        then (amount == stakedByUser)
469
469
 
        else false)
470
470
 
        then deleteNodeActions(listName, userAddressStr)
471
471
 
        else nil
472
472
 
    let refreshStakedVote = if ((amount == stakedByUser))
473
473
 
        then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
474
474
 
        else unit
475
475
 
    if ((refreshStakedVote == refreshStakedVote))
476
476
 
        then {
477
477
 
            let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
478
478
 
            let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
479
479
 
            let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
480
480
 
            let throwIfNothingToClaim = true
481
481
 
            let r = if ((availableToClaim > zeroBigInt))
482
482
 
                then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
483
483
 
                else unit
484
484
 
            if ((r == r))
485
485
 
                then if ((amount > stakedByUser))
486
486
 
                    then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
487
487
 
                    else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
488
488
 
                else throw("Strict value is not equal to itself.")
489
489
 
            }
490
490
 
        else throw("Strict value is not equal to itself.")
491
491
 
    }
492
492
 
493
493
 
494
494
 
@Callable(i)
495
495
 
func constructor (factoryAddressStr) = {
496
496
 
    let checkCaller = mustManager(i)
497
497
 
    if ((checkCaller == checkCaller))
498
498
 
        then [StringEntry(keyFactoryAddress(), factoryAddressStr)]
499
499
 
        else throw("Strict value is not equal to itself.")
500
500
 
    }
501
501
 
502
502
 
503
503
 
504
504
 
@Callable(i)
505
505
 
func constructorV2 (votingEmissionContract) = {
506
506
 
    let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
507
507
 
        then true
508
508
 
        else "invalid voting emission contract address"]
509
509
 
    if ((cheks == cheks))
510
510
 
        then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
511
511
 
        else throw("Strict value is not equal to itself.")
512
512
 
    }
513
513
 
514
514
 
515
515
 
516
516
 
@Callable(i)
517
517
 
func setManager (pendingManagerPublicKey) = {
518
518
 
    let checkCaller = mustManager(i)
519
519
 
    if ((checkCaller == checkCaller))
520
520
 
        then {
521
521
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
522
522
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
523
523
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
524
524
 
                else throw("Strict value is not equal to itself.")
525
525
 
            }
526
526
 
        else throw("Strict value is not equal to itself.")
527
527
 
    }
528
528
 
529
529
 
530
530
 
531
531
 
@Callable(i)
532
532
 
func confirmManager () = {
533
533
 
    let pm = pendingManagerPublicKeyOrUnit()
534
534
 
    let hasPM = if (isDefined(pm))
535
535
 
        then true
536
536
 
        else throwErr("No pending manager")
537
537
 
    if ((hasPM == hasPM))
538
538
 
        then {
539
539
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
540
540
 
                then true
541
541
 
                else throwErr("You are not pending manager")
542
542
 
            if ((checkPM == checkPM))
543
543
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
544
544
 
                else throw("Strict value is not equal to itself.")
545
545
 
            }
546
546
 
        else throw("Strict value is not equal to itself.")
547
547
 
    }
548
548
 
549
549
 
550
550
 
551
551
 
@Callable(i)
552
552
 
func stake () = if ((size(i.payments) != 1))
553
553
 
    then throwErr("invalid payment - exact one payment must be attached")
554
554
 
    else {
555
555
 
        let pmt = i.payments[0]
556
556
 
        let lpAssetId = value(pmt.assetId)
557
557
 
        let lpAssetIdStr = toBase58String(lpAssetId)
558
558
 
        let amount = pmt.amount
559
559
 
        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
560
560
 
        let poolAddress = addressFromStringValue(poolAddressStr)
561
561
 
        let userAddress = if ((i.caller == poolAddress))
562
562
 
            then i.originCaller
563
563
 
            else i.caller
564
564
 
        stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
565
565
 
        }
566
566
 
567
567
 
568
568
 
569
569
 
@Callable(i)
570
570
 
func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
571
571
 
    then throwErr("invalid payment - exact one payment must be attached")
572
572
 
    else {
573
573
 
        let pmt = i.payments[0]
574
574
 
        let lpAssetId = value(pmt.assetId)
575
575
 
        let lpAssetIdStr = toBase58String(lpAssetId)
576
576
 
        let amount = pmt.amount
577
577
 
        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
578
578
 
        let poolAddress = addressFromStringValue(poolAddressStr)
579
579
 
        let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
580
580
 
        stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
581
581
 
        }
582
582
 
583
583
 
584
584
 
585
585
 
@Callable(i)
586
586
 
func unstake (lpAssetIdStr,amount) = {
587
587
 
    let lpAssetId = fromBase58String(lpAssetIdStr)
588
588
 
    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
589
589
 
    let poolAddress = addressFromStringValue(poolAddressStr)
590
590
 
    let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
591
591
 
    let callerStr = toString(i.caller)
592
592
 
    let userAddress = if (if ((callerStr == poolAddressStr))
593
593
 
        then true
594
594
 
        else (callerStr == poolAddon))
595
595
 
        then i.originCaller
596
596
 
        else i.caller
597
597
 
    let lpAssetRecipientAddress = i.caller
598
598
 
    unstakeActions(i, lpAssetId, poolAddress, userAddress, lpAssetRecipientAddress, amount)
599
599
 
    }
600
600
 
601
601
 
602
602
 
603
603
 
@Callable(i)
604
604
 
func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
605
605
 
    let lpAssetIdStr = toBase58String(lpAssetId)
606
606
 
    let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr))))
607
607
 
    let checkCaller = if ((i.caller == poolAddress))
608
608
 
        then true
609
609
 
        else permissionDeniedError
610
610
 
    if ((checkCaller == checkCaller))
611
611
 
        then unstakeActions(i, lpAssetId, poolAddress, Address(userAddress), Address(lpAssetRecipientAddress), amount)
612
612
 
        else throw("Strict value is not equal to itself.")
613
613
 
    }
614
614
 
615
615
 
616
616
 
617
617
 
@Callable(i)
618
618
 
func claimWx (lpAssetIdStr) = {
619
619
 
    let userAddressStr = toString(i.caller)
620
620
 
    let throwIfNothingToClaim = true
621
621
 
    let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
622
622
 
    $Tuple2(nil, result)
623
623
 
    }
624
624
 
625
625
 
626
626
 
627
627
 
@Callable(i)
628
628
 
func claimWxDoNotThrow (lpAssetIdStr) = {
629
629
 
    let userAddressStr = toString(i.caller)
630
630
 
    let throwIfNothingToClaim = false
631
631
 
    let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
632
632
 
    $Tuple2(nil, result)
633
633
 
    }
634
634
 
635
635
 
636
636
 
637
637
 
@Callable(i)
638
638
 
func claimWxINTERNAL (lpAssetIdStr,userAddressStr,throwIfNothingToClaim) = {
639
639
 
    let checkCaller = mustThis(i)
640
640
 
    if ((checkCaller == checkCaller))
641
641
 
        then {
642
642
 
            let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
643
643
 
            let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
644
644
 
            let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
645
645
 
            let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
646
646
 
            let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
647
647
 
            let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
648
648
 
            let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
649
649
 
            let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
650
650
 
            let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
651
651
 
            let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
652
652
 
            let $t02631426426 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
653
653
 
            let wxToClaimUserNew = $t02631426426._1
654
654
 
            let integralSTATE = $t02631426426._2
655
655
 
            let debug = $t02631426426._3
656
656
 
            let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
657
657
 
            if ((zeroBigInt >= availableToClaim))
658
658
 
                then if (throwIfNothingToClaim)
659
659
 
                    then throwErr("nothing to claim")
660
660
 
                    else $Tuple2(nil, 0)
661
661
 
                else {
662
662
 
                    let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
663
663
 
                    let minRewardPart = availableToClaim
664
664
 
                    let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
665
665
 
                    let totalReward = (minRewardPart + boostRewardPart)
666
666
 
                    let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
667
667
 
                    let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
668
668
 
                    if ((emitBoost == emitBoost))
669
669
 
                        then {
670
670
 
                            let claimedByUserValue = ((claimedByUser + minRewardPart) + boostRewardPart)
671
671
 
                            let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
672
672
 
                            let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserBoostReward + boostRewardPart)
673
673
 
                            let claimedTotalPlusAvailableToClaim = (claimedTotal + availableToClaim)
674
674
 
                            $Tuple2([StringEntry(claimedByUserKEY, toString(claimedByUserValue)), StringEntry(claimedByUserMinRewardKEY, toString(claimedByUserMinRewardPlusPart)), StringEntry(claimedByUserBoostRewardKEY, toString(claimedByUserBoostRewardPlusBoostRewardPart)), StringEntry(claimedTotalKEY, toString(claimedTotalPlusAvailableToClaim)), ScriptTransfer(userAddress, toInt(minRewardPart), wxAssetId), ScriptTransfer(userAddress, toInt(boostRewardPart), wxAssetId), OperationHistoryEntry("claim", userAddressStr, lpAssetIdStr, toInt(availableToClaim), i.transactionId)], toInt(totalReward))
675
675
 
                            }
676
676
 
                        else throw("Strict value is not equal to itself.")
677
677
 
                    }
678
678
 
            }
679
679
 
        else throw("Strict value is not equal to itself.")
680
680
 
    }
681
681
 
682
682
 
683
683
 
684
684
 
@Callable(i)
685
685
 
func claimWxBulkInternalREADONLY (currentIter,lpAssetIds,userAddressStr,resAcc) = if ((currentIter == size(lpAssetIds)))
686
686
 
    then $Tuple2(nil, resAcc)
687
687
 
    else {
688
688
 
        let lpAssetId = lpAssetIds[currentIter]
689
689
 
        let info = split({
690
690
 
            let @ = invoke(this, "claimWxREADONLY", [lpAssetId, userAddressStr], nil)
691
691
 
            if ($isInstanceOf(@, "String"))
692
692
 
                then @
693
693
 
                else throw(($getType(@) + " couldn't be cast to String"))
694
694
 
            }, SEP)
695
695
 
        let unclaimed = info[3]
696
696
 
        let claimed = info[4]
697
697
 
        let userVoteFinalized = {
698
698
 
            let @ = invoke(boostingContract, "getUserVoteFinalizedREADONLY", [lpAssetId, userAddressStr], nil)
699
699
 
            if ($isInstanceOf(@, "Int"))
700
700
 
                then @
701
701
 
                else throw(($getType(@) + " couldn't be cast to Int"))
702
702
 
            }
703
703
 
        let res = (resAcc :+ makeString(["%d%d%d", unclaimed, claimed, toString(userVoteFinalized)], SEP))
704
704
 
        let inv = {
705
705
 
            let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
706
706
 
            if ($isInstanceOf(@, "List[Any]"))
707
707
 
                then @
708
708
 
                else throw(($getType(@) + " couldn't be cast to List[Any]"))
709
709
 
            }
710
710
 
        if ((inv == inv))
711
711
 
            then $Tuple2(nil, inv)
712
712
 
            else throw("Strict value is not equal to itself.")
713
713
 
        }
714
714
 
715
715
 
716
716
 
717
717
 
@Callable(i)
718
718
 
func claimWxBulkREADONLY (lpAssetIds,userAddressStr) = {
719
719
 
    let res = invoke(this, "claimWxBulkInternalREADONLY", [0, lpAssetIds, userAddressStr, nil], nil)
720
720
 
    $Tuple2(nil, res)
721
721
 
    }
722
722
 
723
723
 
724
724
 
725
725
 
@Callable(i)
726
726
 
func claimWxREADONLY (lpAssetIdStr,userAddressStr) = {
727
727
 
    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
728
728
 
    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
729
729
 
    let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
730
730
 
    let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
731
731
 
    let stakedByUser = readStaked(stakedByUserKEY)
732
732
 
    let stakedTotal = readStaked(stakedTotalKEY)
733
733
 
    let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
734
734
 
    let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
735
735
 
    let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
736
736
 
    let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
737
737
 
    let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
738
738
 
    let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
739
739
 
    let passedBlocks = if ((emissionStartBlock > height))
740
740
 
        then 0
741
741
 
        else (height - emissionStartBlock)
742
742
 
    let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
743
743
 
    let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
744
744
 
    let $t03047730589 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
745
745
 
    let wxToClaimUserNew = $t03047730589._1
746
746
 
    let integralSTATE = $t03047730589._2
747
747
 
    let debug = $t03047730589._3
748
748
 
    let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
749
749
 
    let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
750
750
 
    let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
751
751
 
    let boostDebug = asString(boostInvResult[1])
752
752
 
    let minRewardPart = availableToClaim
753
753
 
    let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
754
754
 
    let totalReward = (minRewardPart + boostRewardPart)
755
755
 
    $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
756
756
 
    }
757
757
 
758
758
 
759
759
 
760
760
 
@Callable(i)
761
761
 
func stakedByUserREADONLY (lpAssetIdStr,userAddressStr) = {
762
762
 
    let stakedByUser = valueOrElse(getInteger(keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
763
763
 
    $Tuple2(nil, stakedByUser)
764
764
 
    }
765
765
 
766
766
 
767
767
 
768
768
 
@Callable(i)
769
+
func stakedTotalREADONLY (lpAssetIdStr) = {
770
+
    let stakedTotal = valueOrElse(getInteger(keyStakedTotal(lpAssetIdStr)), 0)
771
+
    $Tuple2(nil, stakedTotal)
772
+
    }
773
+
774
+
775
+
776
+
@Callable(i)
769
777
 
func usersListTraversal (lpAssetId) = {
770
778
 
    let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
771
779
 
        then true
772
780
 
        else mustManager(i)
773
781
 
    if ((checkCaller == checkCaller))
774
782
 
        then {
775
783
 
            let listName = getUsersListName(lpAssetId)
776
784
 
            let userOrUnit = getString(keyNextUser(lpAssetId))
777
785
 
            let headOrUnit = getString(keyListHead(listName))
778
786
 
            match userOrUnit {
779
787
 
                case _: Unit => 
780
788
 
                    match headOrUnit {
781
789
 
                        case _: Unit => 
782
790
 
                            $Tuple2(nil, false)
783
791
 
                        case head: String => 
784
792
 
                            $Tuple2([StringEntry(keyNextUser(lpAssetId), head)], true)
785
793
 
                        case _ => 
786
794
 
                            throw("Match error")
787
795
 
                    }
788
796
 
                case userAddress: String => 
789
797
 
                    let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetId, userAddress))
790
798
 
                    let poolAddress = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
791
799
 
                    let wxToClaimUserNew = refreshINTEGRALS(lpAssetId, userAddress, poolAddress, 0)._1
792
800
 
                    let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
793
801
 
                    let throwIfNothingToClaim = true
794
802
 
                    let r = if ((availableToClaim > zeroBigInt))
795
803
 
                        then invoke(this, "claimWxINTERNAL", [lpAssetId, userAddress, throwIfNothingToClaim], nil)
796
804
 
                        else unit
797
805
 
                    if ((r == r))
798
806
 
                        then {
799
807
 
                            let nextUserOrUnit = getString(keyListNext(listName, userAddress))
800
808
 
                            match nextUserOrUnit {
801
809
 
                                case _: Unit => 
802
810
 
                                    $Tuple2([DeleteEntry(keyNextUser(lpAssetId))], false)
803
811
 
                                case nextUser: String => 
804
812
 
                                    $Tuple2([StringEntry(keyNextUser(lpAssetId), nextUser)], true)
805
813
 
                                case _ => 
806
814
 
                                    throw("Match error")
807
815
 
                            }
808
816
 
                            }
809
817
 
                        else throw("Strict value is not equal to itself.")
810
818
 
                case _ => 
811
819
 
                    throw("Match error")
812
820
 
            }
813
821
 
            }
814
822
 
        else throw("Strict value is not equal to itself.")
815
823
 
    }
816
824
 
817
825
 
818
826
 
819
827
 
@Callable(i)
820
828
 
func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
821
829
 
    then throwErr("permissions denied")
822
830
 
    else {
823
-
        let $t03321333323 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
824
-
        let wxPerLpIntegralNew = $t03321333323._1
825
-
        let poolIntegralSTATE = $t03321333323._2
826
-
        let poolDEBUG = $t03321333323._3
831
+
        let $t03337933489 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
832
+
        let wxPerLpIntegralNew = $t03337933489._1
833
+
        let poolIntegralSTATE = $t03337933489._2
834
+
        let poolDEBUG = $t03337933489._3
827
835
 
        poolIntegralSTATE
828
836
 
        }
829
837
 
830
838
 
831
839
 
@Verifier(tx)
832
840
 
func verify () = {
833
841
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
834
842
 
        case pk: ByteVector => 
835
843
 
            pk
836
844
 
        case _: Unit => 
837
845
 
            tx.senderPublicKey
838
846
 
        case _ => 
839
847
 
            throw("Match error")
840
848
 
    }
841
849
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
842
850
 
    }
843
851
 

github/deemru/w8io/fabc49c 
93.95 ms ◑