tx · Djz7ee27LvVChWjoBCadUpWCKSCUBWaybYSjtGtfcEVH

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.02400000 Waves

2023.05.02 14:32 [2560086] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

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

View: original | compacted
Prev: Fxy6e2QGkatqZU7QT6sx8HAKTopY12XGXkVVoVtvm2Lm
Next: 4vzT63LRv1LELbTyZ6kyXMNVSTqMRb2e4P95sd3nc3K2

Diff: 
Old
New
Differences
118
118
 
119
119
 
120
120
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
121
-
122
-
123
-
func keyStablePoolAddonAddr () = "%s__stablePoolAddonAddr"
124
-
125
-
126
-
func keyAddonAddr () = "%s__addonAddr"
127
121
 
128
122
 
129
123
 
func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
365
359
 
366
360
 
367
361
 
func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
368
-
    let $t01481914941 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
369
-
    let wxPerLpIntegralNew = $t01481914941._1
370
-
    let poolIntegralSTATE = $t01481914941._2
371
-
    let poolDEBUG = $t01481914941._3
362
+
    let $t01472314845 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
363
+
    let wxPerLpIntegralNew = $t01472314845._1
364
+
    let poolIntegralSTATE = $t01472314845._2
365
+
    let poolDEBUG = $t01472314845._3
372
366
 
    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
373
367
 
    let stakedByUser = readStaked(stakedByUserKEY)
374
368
 
    let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
440
434
 
    if ((refreshStakedVote == refreshStakedVote))
441
435
 
        then {
442
436
 
            let stakedTotal = readStaked(stakedTotalKEY)
443
-
            let $t01816018277 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
444
-
            let wxToClaimUserNew = $t01816018277._1
445
-
            let integralSTATE = $t01816018277._2
446
-
            let debug = $t01816018277._3
437
+
            let $t01806418181 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
438
+
            let wxToClaimUserNew = $t01806418181._1
439
+
            let integralSTATE = $t01806418181._2
440
+
            let debug = $t01806418181._3
447
441
 
            let listName = getUsersListName(lpAssetIdStr)
448
442
 
            let listActions = if (containsNode(listName, userAddressStr))
449
443
 
                then nil
587
581
 
    let lpAssetId = fromBase58String(lpAssetIdStr)
588
582
 
    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
589
583
 
    let poolAddress = addressFromStringValue(poolAddressStr)
590
-
    let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
591
584
 
    let callerStr = toString(i.caller)
592
-
    let userAddress = if (if ((callerStr == poolAddressStr))
593
-
        then true
594
-
        else (callerStr == poolAddon))
585
+
    let userAddress = if ((callerStr == poolAddressStr))
595
586
 
        then i.originCaller
596
587
 
        else i.caller
597
588
 
    let lpAssetRecipientAddress = i.caller
649
640
 
            let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
650
641
 
            let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
651
642
 
            let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
652
-
            let $t02631426426 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
653
-
            let wxToClaimUserNew = $t02631426426._1
654
-
            let integralSTATE = $t02631426426._2
655
-
            let debug = $t02631426426._3
643
+
            let $t02599726109 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
644
+
            let wxToClaimUserNew = $t02599726109._1
645
+
            let integralSTATE = $t02599726109._2
646
+
            let debug = $t02599726109._3
656
647
 
            let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
657
648
 
            if ((zeroBigInt >= availableToClaim))
658
649
 
                then if (throwIfNothingToClaim)
741
732
 
        else (height - emissionStartBlock)
742
733
 
    let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
743
734
 
    let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
744
-
    let $t03047730589 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
745
-
    let wxToClaimUserNew = $t03047730589._1
746
-
    let integralSTATE = $t03047730589._2
747
-
    let debug = $t03047730589._3
735
+
    let $t03016030272 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
736
+
    let wxToClaimUserNew = $t03016030272._1
737
+
    let integralSTATE = $t03016030272._2
738
+
    let debug = $t03016030272._3
748
739
 
    let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
749
740
 
    let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
750
741
 
    let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
828
819
 
func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
829
820
 
    then throwErr("permissions denied")
830
821
 
    else {
831
-
        let $t03337933489 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
832
-
        let wxPerLpIntegralNew = $t03337933489._1
833
-
        let poolIntegralSTATE = $t03337933489._2
834
-
        let poolDEBUG = $t03337933489._3
822
+
        let $t03306233172 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
823
+
        let wxPerLpIntegralNew = $t03306233172._1
824
+
        let poolIntegralSTATE = $t03306233172._2
825
+
        let poolDEBUG = $t03306233172._3
835
826
 
        poolIntegralSTATE
836
827
 
        }
837
828
 

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

github/deemru/w8io/3ef1775 
126.20 ms ◑