tx · BnxhjRvsFxx5GWYAGufgqtCv1BbJxM2tH3hs67eYkZd7

3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h:  -0.01100000 Waves

2024.02.12 18:53 [2973243] smart account 3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BnxhjRvsFxx5GWYAGufgqtCv1BbJxM2tH3hs67eYkZd7",
    "fee": 1100000,
    "feeAssetId": null,
    "timestamp": 1707753278988,
    "version": 2,
    "chainId": 84,
    "sender": "3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h",
    "senderPublicKey": "3z8Q6Zu3KppVmn6fJJvrLc1Wo3krVHSvfaNcerm82md2",
    "proofs": [
        "44gWbr1hoa99SMgSeBrDVutpkDNHzEaQtMBxkDWGprtrFpubuWnFnfv3zZtZndhfn54bNExfNZVxf23kcr5rttJy"
    ],
    "script": "base64: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",
    "height": 2973243,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 78wCSZXshmt5KwAVGPkv6nGCgo7PRKLS1Wa3roxGAkZi
Next: ovpcsZnbKjoEq79eq2Ycohf1Zj8USiv3BW2zLRdw1PQ

Diff: 
Old
New
Differences
232
232
 
            let newUserNextLeased = (userNextLeased + userLeasingAmount)
233
233
 
            let newToUnlock = max([0, (toUnlock - userLeasingAmount)])
234
234
 
            let newToClaim = min([toClaim, (toClaim + (toUnlock - userLeasingAmount))])
235
-
[getLeasingNodeEntry(nodeAddress, nodeCurrentLeased, nodeNextLeased), getUserLeasingEntry(nodeAddress, userAddress, userCurrentLeased, newUserNextLeased), getUserToClaimEntry(userAddress, newToClaim, newToUnlock)]
235
+
[getLeasingNodeEntry(nodeAddress, nodeCurrentLeased, newNodeNextLease), getUserLeasingEntry(nodeAddress, userAddress, userCurrentLeased, newUserNextLeased), getUserToClaimEntry(userAddress, newToClaim, newToUnlock)]
236
236
 
            }
237
237
 
        else throw("Strict value is not equal to itself.")
238
238
 
    }
245
245
 
    if ((check == check))
246
246
 
        then if ((periodOffsetHeight == -1))
247
247
 
            then [IntegerEntry(keyPeriodLength, newPeriodLength), IntegerEntry(keyPeriodOffsetHeight, height)]
248
-
            else {
249
-
                let newPeriodOffsetId = (currentPeriodId + 1)
250
-
                let newOffsetHeight = ((periodLength * (newPeriodOffsetId - periodOffsetId)) + periodOffsetHeight)
251
-
[IntegerEntry(keyPeriodOffsetId, newPeriodOffsetId), IntegerEntry(keyPeriodOffsetHeight, newOffsetHeight), IntegerEntry(keyPeriodLength, newPeriodLength)]
252
-
                }
248
+
            else [IntegerEntry(keyPeriodOffsetId, (currentPeriodId + 1)), IntegerEntry(keyPeriodOffsetHeight, nextPeriodHeight), IntegerEntry(keyPeriodLength, newPeriodLength)]
253
249
 
        else throw("Strict value is not equal to itself.")
254
250
 
    }
255
251
 
261
257
 
262
258
 
@Callable(i)
263
259
 
func getNodeDataREADONLY (nodeAddress) = {
264
-
    let $t01026110325 = getLeasingNodeData(nodeAddress)
265
-
    let currentLease = $t01026110325._1
266
-
    let nextLeased = $t01026110325._2
260
+
    let $t01010810172 = getLeasingNodeData(nodeAddress)
261
+
    let currentLease = $t01010810172._1
262
+
    let nextLeased = $t01010810172._2
267
263
 
    $Tuple2(nil, $Tuple5(currentPeriodHeight, currentLease, nextPeriodHeight, nextLeased, height))
268
264
 
    }
269
265
 
271
267
 
272
268
 
@Callable(i)
273
269
 
func getUserDataREADONLY (userAddress) = {
274
-
    let $t01048110541 = getUserToClaimBalance(userAddress)
275
-
    let toClaim = $t01048110541._1
276
-
    let toUnlock = $t01048110541._2
270
+
    let $t01032810388 = getUserToClaimBalance(userAddress)
271
+
    let toClaim = $t01032810388._1
272
+
    let toUnlock = $t01032810388._2
277
273
 
    $Tuple2(nil, $Tuple5(currentPeriodHeight, toClaim, nextPeriodHeight, toUnlock, height))
278
274
 
    }
279
275
 
319
315
 
@Callable(i)
320
316
 
func claimAll () = {
321
317
 
    let userAddress = toString(i.caller)
322
-
    let $t01145911519 = getUserToClaimBalance(userAddress)
323
-
    let toClaim = $t01145911519._1
324
-
    let toUnlock = $t01145911519._2
325
-
    getClaimUnlockedActions(userAddress, toClaim)
318
+
    let $t01130611366 = getUserToClaimBalance(userAddress)
319
+
    let toClaim = $t01130611366._1
320
+
    let toUnlock = $t01130611366._2
321
+
    let checks = [if ((toClaim > 0))
322
+
        then true
323
+
        else throwErr("nothing to claim")]
324
+
    if ((checks == checks))
325
+
        then getClaimUnlockedActions(userAddress, toClaim)
326
+
        else throw("Strict value is not equal to itself.")
326
327
 
    }
327
328
 
328
329
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let contractFile = "l2mp_leasing.ride"
5
5
 
6
6
 
let SEP = "__"
7
7
 
8
8
 
func throwErr (msg) = throw(((contractFile + ": ") + msg))
9
9
 
10
10
 
11
11
 
let keyAssetId = makeString(["%s", "assetId"], SEP)
12
12
 
13
13
 
let keyPeriodOffsetId = makeString(["%s", "offsetId"], SEP)
14
14
 
15
15
 
let keyPeriodOffsetHeight = makeString(["%s", "offsetHeight"], SEP)
16
16
 
17
17
 
let keyPeriodLength = makeString(["%s", "periodLength"], SEP)
18
18
 
19
19
 
let periodOffsetId = valueOrElse(getInteger(this, keyPeriodOffsetId), 0)
20
20
 
21
21
 
let periodLength = valueOrElse(getInteger(this, keyPeriodLength), 10000)
22
22
 
23
23
 
let periodOffsetHeight = valueOrElse(getInteger(this, keyPeriodOffsetHeight), -1)
24
24
 
25
25
 
let currentPeriodId = if (if ((height > periodOffsetHeight))
26
26
 
    then (periodOffsetHeight != -1)
27
27
 
    else false)
28
28
 
    then (((height - periodOffsetHeight) / periodLength) + periodOffsetId)
29
29
 
    else max([0, (periodOffsetId - 1)])
30
30
 
31
31
 
let currentPeriodHeight = (periodOffsetHeight + ((currentPeriodId - periodOffsetId) * periodLength))
32
32
 
33
33
 
let nextPeriodHeight = (currentPeriodHeight + periodLength)
34
34
 
35
35
 
func keyLeasingNodeData (nodeAddress) = makeString(["%s", nodeAddress], SEP)
36
36
 
37
37
 
38
38
 
func keyUserToClaim (userAddress) = makeString(["%s%s", "toClaim", userAddress], SEP)
39
39
 
40
40
 
41
41
 
func keyUserLeasingNodeData (userAddress,nodeAddress) = makeString(["%s%s", nodeAddress, userAddress], SEP)
42
42
 
43
43
 
44
44
 
let assetIdString = valueOrElse(getString(this, keyAssetId), "WAVES")
45
45
 
46
46
 
let assetIdBytes = if ((assetIdString == "WAVES"))
47
47
 
    then unit
48
48
 
    else fromBase58String(assetIdString)
49
49
 
50
50
 
func isValidAddress (address) = match addressFromString(address) {
51
51
 
    case a: Address => 
52
52
 
        true
53
53
 
    case _ => 
54
54
 
        false
55
55
 
}
56
56
 
57
57
 
58
58
 
func getLeasingNodeEntry (nodeAddress,currentLeased,nextLeased) = {
59
59
 
    let valueString = makeString(["%d%d%d%d", toString(currentPeriodHeight), toString(currentLeased), toString(nextPeriodHeight), toString(nextLeased)], SEP)
60
60
 
    StringEntry(keyLeasingNodeData(nodeAddress), valueString)
61
61
 
    }
62
62
 
63
63
 
64
64
 
func getLeasingNodeData (nodeAddress) = {
65
65
 
    let leasingNodeDataStringRaw = getString(this, keyLeasingNodeData(nodeAddress))
66
66
 
    match leasingNodeDataStringRaw {
67
67
 
        case ds: String => 
68
68
 
            let dataList = split(ds, SEP)
69
69
 
            let nodeCurrentPeriod = parseIntValue(dataList[1])
70
70
 
            let nodeCurrentLeased = parseIntValue(dataList[2])
71
71
 
            let nodeNextPeriod = parseIntValue(dataList[3])
72
72
 
            let nodeNextLeased = parseIntValue(dataList[4])
73
73
 
            if ((nodeNextPeriod > height))
74
74
 
                then $Tuple2(nodeCurrentLeased, nodeNextLeased)
75
75
 
                else $Tuple2(nodeNextLeased, nodeNextLeased)
76
76
 
        case _ => 
77
77
 
            $Tuple2(0, 0)
78
78
 
    }
79
79
 
    }
80
80
 
81
81
 
82
82
 
func getUserLeasingEntry (nodeAddress,userAddress,userCurrentLeased,userNextLeased) = {
83
83
 
    let valueString = makeString(["%d%d%d%d", toString(currentPeriodHeight), toString(userCurrentLeased), toString(nextPeriodHeight), toString(userNextLeased)], SEP)
84
84
 
    StringEntry(keyUserLeasingNodeData(userAddress, nodeAddress), valueString)
85
85
 
    }
86
86
 
87
87
 
88
88
 
func getUserLeasingData (nodeAddress,userAddress) = {
89
89
 
    let leasingUserDataStringRaw = getString(this, keyUserLeasingNodeData(userAddress, nodeAddress))
90
90
 
    match leasingUserDataStringRaw {
91
91
 
        case ds: String => 
92
92
 
            let dataList = split(ds, SEP)
93
93
 
            let userCurrentPeriod = parseIntValue(dataList[1])
94
94
 
            let userCurrentLeased = parseIntValue(dataList[2])
95
95
 
            let userNextPeriod = parseIntValue(dataList[3])
96
96
 
            let userNextLeased = parseIntValue(dataList[4])
97
97
 
            if ((userNextPeriod > height))
98
98
 
                then $Tuple2(userCurrentLeased, userNextLeased)
99
99
 
                else $Tuple2(userNextLeased, userNextLeased)
100
100
 
        case _ => 
101
101
 
            $Tuple2(0, 0)
102
102
 
    }
103
103
 
    }
104
104
 
105
105
 
106
106
 
func getUserToClaimEntry (userAddress,toClaim,toUnlock) = {
107
107
 
    let valueString = makeString(["%d%d%d%d", toString(currentPeriodHeight), toString(toClaim), toString(nextPeriodHeight), toString(toUnlock)], SEP)
108
108
 
    StringEntry(keyUserToClaim(userAddress), valueString)
109
109
 
    }
110
110
 
111
111
 
112
112
 
func getUserToClaimBalance (userAddress) = {
113
113
 
    let userToClaimDataStringRaw = getString(this, keyUserToClaim(userAddress))
114
114
 
    match userToClaimDataStringRaw {
115
115
 
        case ds: String => 
116
116
 
            let dataList = split(ds, SEP)
117
117
 
            let currentPeriod = parseIntValue(dataList[1])
118
118
 
            let toClaim = parseIntValue(dataList[2])
119
119
 
            let nextPeriod = parseIntValue(dataList[3])
120
120
 
            let toUnlock = parseIntValue(dataList[4])
121
121
 
            if ((nextPeriod > height))
122
122
 
                then $Tuple2(toClaim, toUnlock)
123
123
 
                else $Tuple2((toClaim + toUnlock), 0)
124
124
 
        case _ => 
125
125
 
            $Tuple2(0, 0)
126
126
 
    }
127
127
 
    }
128
128
 
129
129
 
130
130
 
func getStakeActions (nodeAddress,userAddress,i) = {
131
131
 
    let checks = [if ((size(i.payments) == 1))
132
132
 
        then true
133
133
 
        else throwErr("payment size should be exactly 1"), if ((i.payments[0].assetId == assetIdBytes))
134
134
 
        then true
135
135
 
        else throwErr(makeString(["payment assetId should be:", assetIdString], " ")), if (isValidAddress(nodeAddress))
136
136
 
        then true
137
137
 
        else throwErr(makeString(["node address is not valid:", nodeAddress], " ")), if (isValidAddress(userAddress))
138
138
 
        then true
139
139
 
        else throwErr(makeString(["user address is not valid:", userAddress], " "))]
140
140
 
    if ((checks == checks))
141
141
 
        then {
142
142
 
            let userLeasingAmount = i.payments[0].amount
143
143
 
            let $t055095582 = getLeasingNodeData(nodeAddress)
144
144
 
            let nodeCurrentLeased = $t055095582._1
145
145
 
            let nodeNextLeased = $t055095582._2
146
146
 
            let newNodeNextLease = (nodeNextLeased + userLeasingAmount)
147
147
 
            let $t056505736 = getUserLeasingData(nodeAddress, userAddress)
148
148
 
            let userCurrentLeased = $t056505736._1
149
149
 
            let userNextLeased = $t056505736._2
150
150
 
            let newUserNextLeased = (userNextLeased + userLeasingAmount)
151
151
 
[getLeasingNodeEntry(nodeAddress, nodeCurrentLeased, newNodeNextLease), getUserLeasingEntry(nodeAddress, userAddress, userCurrentLeased, newUserNextLeased)]
152
152
 
            }
153
153
 
        else throw("Strict value is not equal to itself.")
154
154
 
    }
155
155
 
156
156
 
157
157
 
func getUnstakeActions (nodeAddress,userAddress,unstakeAmount) = {
158
158
 
    let $t060806153 = getLeasingNodeData(nodeAddress)
159
159
 
    let nodeCurrentLeased = $t060806153._1
160
160
 
    let nodeNextLeased = $t060806153._2
161
161
 
    let $t061586244 = getUserLeasingData(nodeAddress, userAddress)
162
162
 
    let userCurrentLeased = $t061586244._1
163
163
 
    let userNextLeased = $t061586244._2
164
164
 
    let checks = [if ((unstakeAmount > 0))
165
165
 
        then true
166
166
 
        else throwErr("unstake amount should be greater than 0"), if ((userNextLeased >= unstakeAmount))
167
167
 
        then true
168
168
 
        else throwErr("unstake amount should be less or equal user staked amount"), if ((nodeNextLeased >= unstakeAmount))
169
169
 
        then true
170
170
 
        else throwErr("unstake amount should be less or equal node staked amount"), if (isValidAddress(nodeAddress))
171
171
 
        then true
172
172
 
        else throwErr(makeString(["node address is not valid:", nodeAddress], " ")), if (isValidAddress(userAddress))
173
173
 
        then true
174
174
 
        else throwErr(makeString(["user address is not valid:", userAddress], " "))]
175
175
 
    if ((checks == checks))
176
176
 
        then {
177
177
 
            let newNodeNextLease = (nodeNextLeased - unstakeAmount)
178
178
 
            let newUserNextLeased = (userNextLeased - unstakeAmount)
179
179
 
            let $t069377042 = getUserToClaimBalance(userAddress)
180
180
 
            let toClaim = $t069377042._1
181
181
 
            let toUnlock = $t069377042._2
182
182
 
            let newToUnlock = (toUnlock + unstakeAmount)
183
183
 
[getLeasingNodeEntry(nodeAddress, nodeCurrentLeased, newNodeNextLease), getUserLeasingEntry(nodeAddress, userAddress, userCurrentLeased, newUserNextLeased), getUserToClaimEntry(userAddress, toClaim, newToUnlock)]
184
184
 
            }
185
185
 
        else throw("Strict value is not equal to itself.")
186
186
 
    }
187
187
 
188
188
 
189
189
 
func getClaimUnlockedActions (userAddress,claimAmount) = {
190
190
 
    let $t074177477 = getUserToClaimBalance(userAddress)
191
191
 
    let toClaim = $t074177477._1
192
192
 
    let toUnlock = $t074177477._2
193
193
 
    let checks = [if ((claimAmount > 0))
194
194
 
        then true
195
195
 
        else throwErr("claim amount should be greater than 0"), if ((toClaim >= claimAmount))
196
196
 
        then true
197
197
 
        else throwErr("claim amount should be less or equal unlocked amount"), if (isValidAddress(userAddress))
198
198
 
        then true
199
199
 
        else throwErr(makeString(["user address is not valid:", userAddress], " "))]
200
200
 
    if ((checks == checks))
201
201
 
        then {
202
202
 
            let newToClaim = (toClaim - claimAmount)
203
203
 
[getUserToClaimEntry(userAddress, newToClaim, toUnlock), ScriptTransfer(addressFromStringValue(userAddress), claimAmount, assetIdBytes)]
204
204
 
            }
205
205
 
        else throw("Strict value is not equal to itself.")
206
206
 
    }
207
207
 
208
208
 
209
209
 
func getStakeFromUnlockedActions (nodeAddress,userAddress,userLeasingAmount) = {
210
210
 
    let $t081178177 = getUserToClaimBalance(userAddress)
211
211
 
    let toClaim = $t081178177._1
212
212
 
    let toUnlock = $t081178177._2
213
213
 
    let available = (toUnlock + toClaim)
214
214
 
    let checks = [if ((userLeasingAmount > 0))
215
215
 
        then true
216
216
 
        else throwErr("amount should be greater than 0"), if ((available >= userLeasingAmount))
217
217
 
        then true
218
218
 
        else throwErr("amount should be less or equal to available"), if (isValidAddress(nodeAddress))
219
219
 
        then true
220
220
 
        else throwErr(makeString(["node address is not valid:", nodeAddress], " ")), if (isValidAddress(userAddress))
221
221
 
        then true
222
222
 
        else throwErr(makeString(["user address is not valid:", userAddress], " "))]
223
223
 
    if ((checks == checks))
224
224
 
        then {
225
225
 
            let $t086548727 = getLeasingNodeData(nodeAddress)
226
226
 
            let nodeCurrentLeased = $t086548727._1
227
227
 
            let nodeNextLeased = $t086548727._2
228
228
 
            let newNodeNextLease = (nodeNextLeased + userLeasingAmount)
229
229
 
            let $t087958881 = getUserLeasingData(nodeAddress, userAddress)
230
230
 
            let userCurrentLeased = $t087958881._1
231
231
 
            let userNextLeased = $t087958881._2
232
232
 
            let newUserNextLeased = (userNextLeased + userLeasingAmount)
233
233
 
            let newToUnlock = max([0, (toUnlock - userLeasingAmount)])
234
234
 
            let newToClaim = min([toClaim, (toClaim + (toUnlock - userLeasingAmount))])
235
-
[getLeasingNodeEntry(nodeAddress, nodeCurrentLeased, nodeNextLeased), getUserLeasingEntry(nodeAddress, userAddress, userCurrentLeased, newUserNextLeased), getUserToClaimEntry(userAddress, newToClaim, newToUnlock)]
235
+
[getLeasingNodeEntry(nodeAddress, nodeCurrentLeased, newNodeNextLease), getUserLeasingEntry(nodeAddress, userAddress, userCurrentLeased, newUserNextLeased), getUserToClaimEntry(userAddress, newToClaim, newToUnlock)]
236
236
 
            }
237
237
 
        else throw("Strict value is not equal to itself.")
238
238
 
    }
239
239
 
240
240
 
241
241
 
func getSetNewPeriodLengthActions (newPeriodLength) = {
242
242
 
    let check = [if ((newPeriodLength > 0))
243
243
 
        then true
244
244
 
        else throwErr("period length should be greater than 0")]
245
245
 
    if ((check == check))
246
246
 
        then if ((periodOffsetHeight == -1))
247
247
 
            then [IntegerEntry(keyPeriodLength, newPeriodLength), IntegerEntry(keyPeriodOffsetHeight, height)]
248
-
            else {
249
-
                let newPeriodOffsetId = (currentPeriodId + 1)
250
-
                let newOffsetHeight = ((periodLength * (newPeriodOffsetId - periodOffsetId)) + periodOffsetHeight)
251
-
[IntegerEntry(keyPeriodOffsetId, newPeriodOffsetId), IntegerEntry(keyPeriodOffsetHeight, newOffsetHeight), IntegerEntry(keyPeriodLength, newPeriodLength)]
252
-
                }
248
+
            else [IntegerEntry(keyPeriodOffsetId, (currentPeriodId + 1)), IntegerEntry(keyPeriodOffsetHeight, nextPeriodHeight), IntegerEntry(keyPeriodLength, newPeriodLength)]
253
249
 
        else throw("Strict value is not equal to itself.")
254
250
 
    }
255
251
 
256
252
 
257
253
 
@Callable(i)
258
254
 
func setNewPeriodLength (newPeriodLength) = getSetNewPeriodLengthActions(newPeriodLength)
259
255
 
260
256
 
261
257
 
262
258
 
@Callable(i)
263
259
 
func getNodeDataREADONLY (nodeAddress) = {
264
-
    let $t01026110325 = getLeasingNodeData(nodeAddress)
265
-
    let currentLease = $t01026110325._1
266
-
    let nextLeased = $t01026110325._2
260
+
    let $t01010810172 = getLeasingNodeData(nodeAddress)
261
+
    let currentLease = $t01010810172._1
262
+
    let nextLeased = $t01010810172._2
267
263
 
    $Tuple2(nil, $Tuple5(currentPeriodHeight, currentLease, nextPeriodHeight, nextLeased, height))
268
264
 
    }
269
265
 
270
266
 
271
267
 
272
268
 
@Callable(i)
273
269
 
func getUserDataREADONLY (userAddress) = {
274
-
    let $t01048110541 = getUserToClaimBalance(userAddress)
275
-
    let toClaim = $t01048110541._1
276
-
    let toUnlock = $t01048110541._2
270
+
    let $t01032810388 = getUserToClaimBalance(userAddress)
271
+
    let toClaim = $t01032810388._1
272
+
    let toUnlock = $t01032810388._2
277
273
 
    $Tuple2(nil, $Tuple5(currentPeriodHeight, toClaim, nextPeriodHeight, toUnlock, height))
278
274
 
    }
279
275
 
280
276
 
281
277
 
282
278
 
@Callable(i)
283
279
 
func stakeFor (nodeAddress,userAddress) = getStakeActions(nodeAddress, userAddress, i)
284
280
 
285
281
 
286
282
 
287
283
 
@Callable(i)
288
284
 
func stake (nodeAddress) = {
289
285
 
    let userAddress = toString(i.caller)
290
286
 
    getStakeActions(nodeAddress, userAddress, i)
291
287
 
    }
292
288
 
293
289
 
294
290
 
295
291
 
@Callable(i)
296
292
 
func stakeFromUnlocked (nodeAddress,amount) = {
297
293
 
    let userAddress = toString(i.caller)
298
294
 
    getStakeFromUnlockedActions(nodeAddress, userAddress, amount)
299
295
 
    }
300
296
 
301
297
 
302
298
 
303
299
 
@Callable(i)
304
300
 
func unstake (nodeAddress,amount) = {
305
301
 
    let userAddress = toString(i.caller)
306
302
 
    getUnstakeActions(nodeAddress, userAddress, amount)
307
303
 
    }
308
304
 
309
305
 
310
306
 
311
307
 
@Callable(i)
312
308
 
func claim (amount) = {
313
309
 
    let userAddress = toString(i.caller)
314
310
 
    getClaimUnlockedActions(userAddress, amount)
315
311
 
    }
316
312
 
317
313
 
318
314
 
319
315
 
@Callable(i)
320
316
 
func claimAll () = {
321
317
 
    let userAddress = toString(i.caller)
322
-
    let $t01145911519 = getUserToClaimBalance(userAddress)
323
-
    let toClaim = $t01145911519._1
324
-
    let toUnlock = $t01145911519._2
325
-
    getClaimUnlockedActions(userAddress, toClaim)
318
+
    let $t01130611366 = getUserToClaimBalance(userAddress)
319
+
    let toClaim = $t01130611366._1
320
+
    let toUnlock = $t01130611366._2
321
+
    let checks = [if ((toClaim > 0))
322
+
        then true
323
+
        else throwErr("nothing to claim")]
324
+
    if ((checks == checks))
325
+
        then getClaimUnlockedActions(userAddress, toClaim)
326
+
        else throw("Strict value is not equal to itself.")
326
327
 
    }
327
328
 
328
329
 

github/deemru/w8io/026f985 
42.79 ms ◑