tx · G3AFXw36cGdNo4g61Ds1njQrrZrhGSA1VScd5uaThvJF

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.01400000 Waves

2023.06.09 17:42 [2615263] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "G3AFXw36cGdNo4g61Ds1njQrrZrhGSA1VScd5uaThvJF",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1686321833561,
    "version": 2,
    "chainId": 84,
    "sender": "3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP",
    "senderPublicKey": "AoKo4segKHU4DeJnxXQYJj2u7J6XJeux6r8KLW52cd2Q",
    "proofs": [
        "4phFzuFJkeA6VYGRDAnFJT8zs5PPYFCi1RtPabDvL5ksZZ5b5pgk7apdFiJ9kNovNKeS9Lk62rag84KVPGZQeMbH"
    ],
    "script": "base64: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",
    "height": 2615263,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: FtF2bR4vkEcAYznJEojvHBjTbdtSXf3GPcjJujzzRHMA
Next: 4KCq3DJDXS3JC2Yjw5ygS9nK9YtTP3eJouE1x76vHZaM

Diff: 
Old
New
Differences
48
48
 
49
49
 
50
50
 
func keyNextBlockToProcess () = "%s__nextBlockToProcess"
51
+
52
+
53
+
func keyBlockProcessed (height) = makeString(["%s%d", "blockProcessed", toString(height)], SEP)
51
54
 
52
55
 
53
56
 
func keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
137
140
 
138
141
 
func rewardForOption (rewards,target) = {
139
142
 
    let s = size(rewards)
140
-
    let $t032473272 = rewards[0]
141
-
    let a0 = $t032473272._1
142
-
    let r0 = $t032473272._2
143
-
    let $t032753300 = rewards[1]
144
-
    let a1 = $t032753300._1
145
-
    let r1 = $t032753300._2
146
-
    let $t033033328 = rewards[2]
147
-
    let a2 = $t033033328._1
148
-
    let r2 = $t033033328._2
143
+
    let $t033473372 = rewards[0]
144
+
    let a0 = $t033473372._1
145
+
    let r0 = $t033473372._2
146
+
    let $t033753400 = rewards[1]
147
+
    let a1 = $t033753400._1
148
+
    let r1 = $t033753400._2
149
+
    let $t034033428 = rewards[2]
150
+
    let a2 = $t034033428._1
151
+
    let r2 = $t034033428._2
149
152
 
    if (if ((s > 0))
150
153
 
        then (a0 == target)
151
154
 
        else false)
271
274
 
        then {
272
275
 
            let userAddress = Address(userAddressBytes)
273
276
 
            let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
274
-
            let $t086058718 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
275
-
            let status = $t086058718._1
276
-
            let lpAssetAmount = $t086058718._2
277
-
            let targetPeriod = $t086058718._3
278
-
            let claimTxId = $t086058718._4
277
+
            let $t087058818 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
278
+
            let status = $t087058818._1
279
+
            let lpAssetAmount = $t087058818._2
280
+
            let targetPeriod = $t087058818._3
281
+
            let claimTxId = $t087058818._4
279
282
 
            if ((status == PENDING))
280
283
 
                then {
281
284
 
                    let factoryActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
298
301
 
            let userAddress = Address(userAddressBytes)
299
302
 
            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
300
303
 
            let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
301
-
            let $t095899702 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
302
-
            let status = $t095899702._1
303
-
            let lpAssetAmount = $t095899702._2
304
-
            let targetPeriod = $t095899702._3
305
-
            let claimTxId = $t095899702._4
304
+
            let $t096899802 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
305
+
            let status = $t096899802._1
306
+
            let lpAssetAmount = $t096899802._2
307
+
            let targetPeriod = $t096899802._3
308
+
            let claimTxId = $t096899802._4
306
309
 
            if ((status == FINISHED))
307
310
 
                then throwErr("invalid withdrawal request status")
308
311
 
                else if ((targetPeriod > currentPeriodOrFail))
332
335
 
            let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
333
336
 
            let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
334
337
 
            let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
335
-
            let targetBlockInfo = if (if (if ((height >= nextBlockToProcess))
338
+
            let periodEndHeight = ((currentStartHeight + periodLength) - 1)
339
+
            let blocksProcessingBatchSizeMax = 5
340
+
            let blocksProcessingBatchSize = if (if (if ((height >= nextBlockToProcess))
336
341
 
                then if ((nextBlockToProcess >= currentStartHeight))
337
342
 
                    then true
338
343
 
                    else (currentPeriodOrFail == 0)
339
344
 
                else false)
340
-
                then ((currentStartHeight + periodLength) > nextBlockToProcess)
345
+
                then (periodEndHeight >= nextBlockToProcess)
341
346
 
                else false)
342
-
                then valueOrErrorMessage(blockInfoByHeight(nextBlockToProcess), wrapErr("invalid block info"))
347
+
                then min([((periodEndHeight - nextBlockToProcess) + 1), blocksProcessingBatchSizeMax])
343
348
 
                else throwErr(wrapErr("invalid target block"))
344
-
            let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, treasuryAddressOrFail), wrapErr("invalid treasury reward"))
345
-
            let generator = targetBlockInfo.generator
346
-
            let blockProcessingRewardOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
347
-
            let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
348
-
            let lpAssetAmount = if ((currentPriceOrFail > 0))
349
-
                then fraction((treasuryRewardOrFail - blockProcessingRewardOrFail), SCALE8, currentPriceOrFail)
350
-
                else 0
351
-
            let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + 1)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil), invoke(factoryAddressOrFail, "transferWaves", [userAddressBytes, blockProcessingRewardOrFail], nil)]
352
-
            $Tuple2(nil, factoryActions)
349
+
            let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
350
+
            let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSize)
351
+
            let blockProcessingRewardByGeneratorRemainder = (blockProcessingReward - (blockProcessingRewardByGenerator * blocksProcessingBatchSize))
352
+
            func map (acc,inc) =             if ((inc >= blocksProcessingBatchSize))
353
+
                then acc
354
+
                else {
355
+
                    let targetBlockHeight = (nextBlockToProcess + inc)
356
+
                    let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
357
+
                    let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, treasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
358
+
                    let generator = targetBlockInfo.generator
359
+
                    let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
360
+
                    let lpAssetAmount = if ((currentPriceOrFail > 0))
361
+
                        then fraction((treasuryRewardOrFail - blockProcessingRewardByGenerator), SCALE8, currentPriceOrFail)
362
+
                        else 0
363
+
                    let factoryActionsSingle = [invoke(factoryAddressOrFail, "integerEntry", [keyBlockProcessed(targetBlockHeight), lpAssetAmount], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil)]
364
+
                    if ((factoryActionsSingle == factoryActionsSingle))
365
+
                        then {
366
+
                            let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
367
+
                                then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
368
+
                                else blockProcessingRewardByGenerator
369
+
                            (acc + callerReward)
370
+
                            }
371
+
                        else throw("Strict value is not equal to itself.")
372
+
                    }
373
+
374
+
            let callerReward = {
375
+
                let $l = [0, 1, 2, 3, 4]
376
+
                let $s = size($l)
377
+
                let $acc0 = 0
378
+
                func $f0_1 ($a,$i) =                 if (($i >= $s))
379
+
                    then $a
380
+
                    else map($a, $l[$i])
381
+
382
+
                func $f0_2 ($a,$i) =                 if (($i >= $s))
383
+
                    then $a
384
+
                    else throw("List size exceeds 5")
385
+
386
+
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
387
+
                }
388
+
            if ((callerReward == callerReward))
389
+
                then {
390
+
                    let actions = [invoke(factoryAddressOrFail, "transferWaves", [userAddressBytes, callerReward], nil), invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + blocksProcessingBatchSize)], nil)]
391
+
                    if ((actions == actions))
392
+
                        then $Tuple2(nil, unit)
393
+
                        else throw("Strict value is not equal to itself.")
394
+
                    }
395
+
                else throw("Strict value is not equal to itself.")
353
396
 
            }
354
397
 
        else throw("Strict value is not equal to itself.")
355
398
 
    }
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 7 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEP = "__"
5
5
 
6
6
 
let CONTRACT_NAME = "calculator.ride"
7
7
 
8
8
 
let SCALE8 = 100000000
9
9
 
10
10
 
let PENDING = "PENDING"
11
11
 
12
12
 
let FINISHED = "FINISHED"
13
13
 
14
14
 
func wrapErr (s) = ((CONTRACT_NAME + ": ") + s)
15
15
 
16
16
 
17
17
 
func throwErr (s) = throw(wrapErr(s))
18
18
 
19
19
 
20
20
 
func keyFactoryAddress () = makeString(["%s", "factory"], SEP)
21
21
 
22
22
 
23
23
 
func keyLpAssetId () = makeString(["%s", "lpAssetId"], SEP)
24
24
 
25
25
 
26
26
 
func keyTreasuryAddress () = makeString(["%s", "treasury"], SEP)
27
27
 
28
28
 
29
29
 
func keyAvailable (userAddress) = makeString(["%s%s", "available", toString(userAddress)], SEP)
30
30
 
31
31
 
32
32
 
func keyClaimed (userAddress) = makeString(["%s%s", "claimed", toString(userAddress)], SEP)
33
33
 
34
34
 
35
35
 
func keyCurrentPeriod () = makeString(["%s", "currentPeriod"], SEP)
36
36
 
37
37
 
38
38
 
func keyPriceForPeriod (period) = makeString(["%s%d", "price", toString(period)], SEP)
39
39
 
40
40
 
41
41
 
func keyStartHeight (period) = makeString(["%s%d", "startHeight", toString(period)], SEP)
42
42
 
43
43
 
44
44
 
func keyPeriodLength () = "%s__periodLength"
45
45
 
46
46
 
47
47
 
func keyBlockProcessingReward () = "%s__blockProcessingReward"
48
48
 
49
49
 
50
50
 
func keyNextBlockToProcess () = "%s__nextBlockToProcess"
51
+
52
+
53
+
func keyBlockProcessed (height) = makeString(["%s%d", "blockProcessed", toString(height)], SEP)
51
54
 
52
55
 
53
56
 
func keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
54
57
 
55
58
 
56
59
 
func valueWithdrawalRequest (status,lpAssetAmount,targetPeriod,claimTxId) = {
57
60
 
    let claimTxIdStr =     match claimTxId {
58
61
 
        case b: ByteVector => 
59
62
 
            toBase58String(b)
60
63
 
        case _: Unit => 
61
64
 
            "SOON"
62
65
 
        case _ => 
63
66
 
            throw("Match error")
64
67
 
    }
65
68
 
    makeString(["%s%d%d%s", status, toString(lpAssetAmount), toString(targetPeriod), claimTxIdStr], SEP)
66
69
 
    }
67
70
 
68
71
 
69
72
 
func parseWithdrawalRequestValueOrFail (s) = {
70
73
 
    let parts = split(s, SEP)
71
74
 
    if ((size(parts) == 5))
72
75
 
        then {
73
76
 
            let status = parts[1]
74
77
 
            let lpAssetAmount = valueOrErrorMessage(parseInt(parts[2]), wrapErr("invalid lpAssetAmount"))
75
78
 
            let targetPeriod = valueOrErrorMessage(parseInt(parts[3]), wrapErr("invalid targetPeriod"))
76
79
 
            let claimTxId = parts[4]
77
80
 
            $Tuple4(status, lpAssetAmount, targetPeriod, claimTxId)
78
81
 
            }
79
82
 
        else throwErr("invalid withdrawal request value")
80
83
 
    }
81
84
 
82
85
 
83
86
 
let factoryAddressOption = match getString(this, keyFactoryAddress()) {
84
87
 
    case s: String => 
85
88
 
        addressFromString(s)
86
89
 
    case _: Unit => 
87
90
 
        unit
88
91
 
    case _ => 
89
92
 
        throw("Match error")
90
93
 
}
91
94
 
92
95
 
let factoryAddressOrFail = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
93
96
 
94
97
 
let lpAssetIdOption = match factoryAddressOption {
95
98
 
    case a: Address => 
96
99
 
        match getString(a, keyLpAssetId()) {
97
100
 
            case s: String => 
98
101
 
                fromBase58String(s)
99
102
 
            case _: Unit => 
100
103
 
                unit
101
104
 
            case _ => 
102
105
 
                throw("Match error")
103
106
 
        }
104
107
 
    case _: Unit => 
105
108
 
        unit
106
109
 
    case _ => 
107
110
 
        throw("Match error")
108
111
 
}
109
112
 
110
113
 
let lpAssetIdOrFail = valueOrErrorMessage(lpAssetIdOption, wrapErr("invalid lpAssetId"))
111
114
 
112
115
 
let treasuryAddressOption = match factoryAddressOption {
113
116
 
    case a: Address => 
114
117
 
        match getString(a, keyTreasuryAddress()) {
115
118
 
            case s: String => 
116
119
 
                addressFromString(s)
117
120
 
            case _: Unit => 
118
121
 
                unit
119
122
 
            case _ => 
120
123
 
                throw("Match error")
121
124
 
        }
122
125
 
    case _: Unit => 
123
126
 
        unit
124
127
 
    case _ => 
125
128
 
        throw("Match error")
126
129
 
}
127
130
 
128
131
 
let treasuryAddressOrFail = valueOrErrorMessage(treasuryAddressOption, wrapErr("invalid treasury address"))
129
132
 
130
133
 
func onlyAddress (i,address) = if ((i.caller == address))
131
134
 
    then true
132
135
 
    else throwErr("permission denied")
133
136
 
134
137
 
135
138
 
func onlyFactory (i) = onlyAddress(i, factoryAddressOrFail)
136
139
 
137
140
 
138
141
 
func rewardForOption (rewards,target) = {
139
142
 
    let s = size(rewards)
140
-
    let $t032473272 = rewards[0]
141
-
    let a0 = $t032473272._1
142
-
    let r0 = $t032473272._2
143
-
    let $t032753300 = rewards[1]
144
-
    let a1 = $t032753300._1
145
-
    let r1 = $t032753300._2
146
-
    let $t033033328 = rewards[2]
147
-
    let a2 = $t033033328._1
148
-
    let r2 = $t033033328._2
143
+
    let $t033473372 = rewards[0]
144
+
    let a0 = $t033473372._1
145
+
    let r0 = $t033473372._2
146
+
    let $t033753400 = rewards[1]
147
+
    let a1 = $t033753400._1
148
+
    let r1 = $t033753400._2
149
+
    let $t034033428 = rewards[2]
150
+
    let a2 = $t034033428._1
151
+
    let r2 = $t034033428._2
149
152
 
    if (if ((s > 0))
150
153
 
        then (a0 == target)
151
154
 
        else false)
152
155
 
        then r0
153
156
 
        else if (if ((s > 1))
154
157
 
            then (a1 == target)
155
158
 
            else false)
156
159
 
            then r1
157
160
 
            else if (if ((s > 2))
158
161
 
                then (a2 == target)
159
162
 
                else false)
160
163
 
                then r2
161
164
 
                else unit
162
165
 
    }
163
166
 
164
167
 
165
168
 
@Callable(i)
166
169
 
func claimLP (userAddressBytes) = {
167
170
 
    let checkCaller = onlyFactory(i)
168
171
 
    if ((checkCaller == checkCaller))
169
172
 
        then {
170
173
 
            let userAddress = Address(userAddressBytes)
171
174
 
            let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
172
175
 
            let claimed = valueOrElse(getInteger(factoryAddressOrFail, keyClaimed(userAddress)), 0)
173
176
 
            let factoryActions = if ((available > 0))
174
177
 
                then [invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, available, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), 0], nil), invoke(factoryAddressOrFail, "stringEntry", [keyClaimed(userAddress), (claimed + available)], nil)]
175
178
 
                else throwErr("nothing to claim")
176
179
 
            $Tuple2(nil, factoryActions)
177
180
 
            }
178
181
 
        else throw("Strict value is not equal to itself.")
179
182
 
    }
180
183
 
181
184
 
182
185
 
183
186
 
@Callable(i)
184
187
 
func finalize (newTreasuryVolumeInWaves,xtnPrice,pwrManagersBonus,treasuryVolumeDiffAllocationCoef) = {
185
188
 
    let checks = [if ((i.originCaller == factoryAddressOrFail))
186
189
 
        then true
187
190
 
        else throwErr("permission denied"), if ((newTreasuryVolumeInWaves >= 0))
188
191
 
        then true
189
192
 
        else throwErr("invalid new treasury volume"), if ((xtnPrice >= 0))
190
193
 
        then true
191
194
 
        else throwErr("invalid XTN price"), if (if ((pwrManagersBonus >= 0))
192
195
 
        then (SCALE8 >= pwrManagersBonus)
193
196
 
        else false)
194
197
 
        then true
195
198
 
        else throwErr("invalid PWR managers bonus"), if (if ((treasuryVolumeDiffAllocationCoef >= -(SCALE8)))
196
199
 
        then (SCALE8 >= treasuryVolumeDiffAllocationCoef)
197
200
 
        else false)
198
201
 
        then true
199
202
 
        else throwErr("invalid treasury volume diff allocation coefficient")]
200
203
 
    if ((checks == checks))
201
204
 
        then {
202
205
 
            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
203
206
 
            let newPeriod = (currentPeriodOrFail + 1)
204
207
 
            let newPrice = SCALE8
205
208
 
            let lpAssetAmountToBurn = 0
206
209
 
            let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyCurrentPeriod(), newPeriod], nil), invoke(factoryAddressOrFail, "integerEntry", [keyPriceForPeriod(newPeriod), newPrice], nil), invoke(factoryAddressOrFail, "burn", [lpAssetAmountToBurn], nil)]
207
210
 
            $Tuple2(nil, factoryActions)
208
211
 
            }
209
212
 
        else throw("Strict value is not equal to itself.")
210
213
 
    }
211
214
 
212
215
 
213
216
 
214
217
 
@Callable(i)
215
218
 
func invest (userAddressBytes) = {
216
219
 
    let checkCaller = onlyFactory(i)
217
220
 
    if ((checkCaller == checkCaller))
218
221
 
        then {
219
222
 
            let userAddress = Address(userAddressBytes)
220
223
 
            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
221
224
 
            let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
222
225
 
            let payment = if ((size(i.payments) == 1))
223
226
 
                then i.payments[0]
224
227
 
                else throwErr("invalid payments")
225
228
 
            let paymentAmount = if (if ((payment.assetId == unit))
226
229
 
                then (payment.amount > 0)
227
230
 
                else false)
228
231
 
                then payment.amount
229
232
 
                else throwErr("invalid payment amount")
230
233
 
            let lpAssetAmount = if ((currentPriceOrFail > 0))
231
234
 
                then fraction(paymentAmount, SCALE8, currentPriceOrFail)
232
235
 
                else 0
233
236
 
            let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", ["invested__WAVES", 0], nil), invoke(factoryAddressOrFail, "reissue", [lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "transferWaves", [treasuryAddressOrFail.bytes, paymentAmount], [AttachedPayment(unit, paymentAmount)])]
234
237
 
            $Tuple2(nil, factoryActions)
235
238
 
            }
236
239
 
        else throw("Strict value is not equal to itself.")
237
240
 
    }
238
241
 
239
242
 
240
243
 
241
244
 
@Callable(i)
242
245
 
func withdraw (userAddressBytes) = {
243
246
 
    let checkCaller = onlyFactory(i)
244
247
 
    if ((checkCaller == checkCaller))
245
248
 
        then {
246
249
 
            let userAddress = Address(userAddressBytes)
247
250
 
            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
248
251
 
            let payment = if ((size(i.payments) == 1))
249
252
 
                then i.payments[0]
250
253
 
                else throwErr(wrapErr("invalid payments"))
251
254
 
            let paymentAssetId = if ((payment.assetId == lpAssetIdOrFail))
252
255
 
                then lpAssetIdOrFail
253
256
 
                else throwErr("invalid payment asset")
254
257
 
            let paymentAmount = if ((payment.amount > 0))
255
258
 
                then payment.amount
256
259
 
                else throwErr("invalid payment amount")
257
260
 
            let factoryActions = [invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, i.transactionId), valueWithdrawalRequest(PENDING, paymentAmount, (currentPeriodOrFail + 1), unit)], nil)]
258
261
 
            if ((factoryActions == factoryActions))
259
262
 
                then $Tuple2([ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)], factoryActions)
260
263
 
                else throw("Strict value is not equal to itself.")
261
264
 
            }
262
265
 
        else throw("Strict value is not equal to itself.")
263
266
 
    }
264
267
 
265
268
 
266
269
 
267
270
 
@Callable(i)
268
271
 
func cancelWithdraw (userAddressBytes,txId) = {
269
272
 
    let checkCaller = onlyFactory(i)
270
273
 
    if ((checkCaller == checkCaller))
271
274
 
        then {
272
275
 
            let userAddress = Address(userAddressBytes)
273
276
 
            let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
274
-
            let $t086058718 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
275
-
            let status = $t086058718._1
276
-
            let lpAssetAmount = $t086058718._2
277
-
            let targetPeriod = $t086058718._3
278
-
            let claimTxId = $t086058718._4
277
+
            let $t087058818 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
278
+
            let status = $t087058818._1
279
+
            let lpAssetAmount = $t087058818._2
280
+
            let targetPeriod = $t087058818._3
281
+
            let claimTxId = $t087058818._4
279
282
 
            if ((status == PENDING))
280
283
 
                then {
281
284
 
                    let factoryActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
282
285
 
                    if ((factoryActions == factoryActions))
283
286
 
                        then $Tuple2(nil, factoryActions)
284
287
 
                        else throw("Strict value is not equal to itself.")
285
288
 
                    }
286
289
 
                else throwErr("invalid withdrawal request status")
287
290
 
            }
288
291
 
        else throw("Strict value is not equal to itself.")
289
292
 
    }
290
293
 
291
294
 
292
295
 
293
296
 
@Callable(i)
294
297
 
func claimWaves (userAddressBytes,txId) = {
295
298
 
    let checkCaller = onlyFactory(i)
296
299
 
    if ((checkCaller == checkCaller))
297
300
 
        then {
298
301
 
            let userAddress = Address(userAddressBytes)
299
302
 
            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
300
303
 
            let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
301
-
            let $t095899702 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
302
-
            let status = $t095899702._1
303
-
            let lpAssetAmount = $t095899702._2
304
-
            let targetPeriod = $t095899702._3
305
-
            let claimTxId = $t095899702._4
304
+
            let $t096899802 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
305
+
            let status = $t096899802._1
306
+
            let lpAssetAmount = $t096899802._2
307
+
            let targetPeriod = $t096899802._3
308
+
            let claimTxId = $t096899802._4
306
309
 
            if ((status == FINISHED))
307
310
 
                then throwErr("invalid withdrawal request status")
308
311
 
                else if ((targetPeriod > currentPeriodOrFail))
309
312
 
                    then throwErr("invalid withdrawal request period")
310
313
 
                    else {
311
314
 
                        let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
312
315
 
                        let amount = if ((currentPriceOrFail > 0))
313
316
 
                            then fraction(lpAssetAmount, currentPriceOrFail, SCALE8)
314
317
 
                            else 0
315
318
 
                        let factoryActions = [invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, txId), valueWithdrawalRequest(FINISHED, lpAssetAmount, targetPeriod, i.transactionId)], nil), invoke(factoryAddressOrFail, "burn", [lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferWaves", [userAddressBytes, amount], nil)]
316
319
 
                        $Tuple2(nil, factoryActions)
317
320
 
                        }
318
321
 
            }
319
322
 
        else throw("Strict value is not equal to itself.")
320
323
 
    }
321
324
 
322
325
 
323
326
 
324
327
 
@Callable(i)
325
328
 
func processBlocks (userAddressBytes) = {
326
329
 
    let checkCaller = onlyFactory(i)
327
330
 
    if ((checkCaller == checkCaller))
328
331
 
        then {
329
332
 
            let userAddress = Address(userAddressBytes)
330
333
 
            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
331
334
 
            let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
332
335
 
            let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
333
336
 
            let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
334
337
 
            let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
335
-
            let targetBlockInfo = if (if (if ((height >= nextBlockToProcess))
338
+
            let periodEndHeight = ((currentStartHeight + periodLength) - 1)
339
+
            let blocksProcessingBatchSizeMax = 5
340
+
            let blocksProcessingBatchSize = if (if (if ((height >= nextBlockToProcess))
336
341
 
                then if ((nextBlockToProcess >= currentStartHeight))
337
342
 
                    then true
338
343
 
                    else (currentPeriodOrFail == 0)
339
344
 
                else false)
340
-
                then ((currentStartHeight + periodLength) > nextBlockToProcess)
345
+
                then (periodEndHeight >= nextBlockToProcess)
341
346
 
                else false)
342
-
                then valueOrErrorMessage(blockInfoByHeight(nextBlockToProcess), wrapErr("invalid block info"))
347
+
                then min([((periodEndHeight - nextBlockToProcess) + 1), blocksProcessingBatchSizeMax])
343
348
 
                else throwErr(wrapErr("invalid target block"))
344
-
            let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, treasuryAddressOrFail), wrapErr("invalid treasury reward"))
345
-
            let generator = targetBlockInfo.generator
346
-
            let blockProcessingRewardOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
347
-
            let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
348
-
            let lpAssetAmount = if ((currentPriceOrFail > 0))
349
-
                then fraction((treasuryRewardOrFail - blockProcessingRewardOrFail), SCALE8, currentPriceOrFail)
350
-
                else 0
351
-
            let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + 1)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil), invoke(factoryAddressOrFail, "transferWaves", [userAddressBytes, blockProcessingRewardOrFail], nil)]
352
-
            $Tuple2(nil, factoryActions)
349
+
            let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
350
+
            let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSize)
351
+
            let blockProcessingRewardByGeneratorRemainder = (blockProcessingReward - (blockProcessingRewardByGenerator * blocksProcessingBatchSize))
352
+
            func map (acc,inc) =             if ((inc >= blocksProcessingBatchSize))
353
+
                then acc
354
+
                else {
355
+
                    let targetBlockHeight = (nextBlockToProcess + inc)
356
+
                    let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
357
+
                    let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, treasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
358
+
                    let generator = targetBlockInfo.generator
359
+
                    let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
360
+
                    let lpAssetAmount = if ((currentPriceOrFail > 0))
361
+
                        then fraction((treasuryRewardOrFail - blockProcessingRewardByGenerator), SCALE8, currentPriceOrFail)
362
+
                        else 0
363
+
                    let factoryActionsSingle = [invoke(factoryAddressOrFail, "integerEntry", [keyBlockProcessed(targetBlockHeight), lpAssetAmount], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil)]
364
+
                    if ((factoryActionsSingle == factoryActionsSingle))
365
+
                        then {
366
+
                            let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
367
+
                                then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
368
+
                                else blockProcessingRewardByGenerator
369
+
                            (acc + callerReward)
370
+
                            }
371
+
                        else throw("Strict value is not equal to itself.")
372
+
                    }
373
+
374
+
            let callerReward = {
375
+
                let $l = [0, 1, 2, 3, 4]
376
+
                let $s = size($l)
377
+
                let $acc0 = 0
378
+
                func $f0_1 ($a,$i) =                 if (($i >= $s))
379
+
                    then $a
380
+
                    else map($a, $l[$i])
381
+
382
+
                func $f0_2 ($a,$i) =                 if (($i >= $s))
383
+
                    then $a
384
+
                    else throw("List size exceeds 5")
385
+
386
+
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
387
+
                }
388
+
            if ((callerReward == callerReward))
389
+
                then {
390
+
                    let actions = [invoke(factoryAddressOrFail, "transferWaves", [userAddressBytes, callerReward], nil), invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + blocksProcessingBatchSize)], nil)]
391
+
                    if ((actions == actions))
392
+
                        then $Tuple2(nil, unit)
393
+
                        else throw("Strict value is not equal to itself.")
394
+
                    }
395
+
                else throw("Strict value is not equal to itself.")
353
396
 
            }
354
397
 
        else throw("Strict value is not equal to itself.")
355
398
 
    }
356
399
 
357
400
 
358
401
 
@Verifier(tx)
359
402
 
func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
360
403
 

github/deemru/w8io/026f985 
58.44 ms ◑