w8 · tx · Cvn···pZz

tx · CvnY1vTbUp4gwZNxTZg7RLxp17EYtPb2AtY7DxKzepZz

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.01500000 Waves

2023.06.09 18:05 [2615286] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

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

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

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

Old	New		Differences
363	363		let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
364	364		then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
365	365		else blockProcessingRewardByGenerator
366		-	let factoryActionsSingle = [invoke(factoryAddressOrFail, "~~integerEntry~~", [keyBlockProcessed(targetBlockHeight), makeString([toBase58String(i.transactionId), toBase58String(userAddressBytes), toString(treasuryRewardOrFail), toString(callerReward), toString(lpAssetAmount)], SEP)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil)]
	366	+	let factoryActionsSingle = [invoke(factoryAddressOrFail, "stringEntry", [keyBlockProcessed(targetBlockHeight), makeString([toBase58String(i.transactionId), toBase58String(userAddressBytes), toString(treasuryRewardOrFail), toString(callerReward), toString(lpAssetAmount)], SEP)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil)]
367	367		if ((factoryActionsSingle == factoryActionsSingle))
368	368		then (acc + callerReward)
369	369		else throw("Strict value is not equal to itself.")

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

github/deemru/w8io/026f985 
46.77 ms ◑