w8 · tx · 2PD···ctW

tx · 2PD7rtQ7L9ZWAiuZVytVyyhqVf9Msn4XDWYpG22fdctW

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.01200000 Waves

2023.06.08 11:48 [2613471] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 8inYyrQ7YNsXYVw5Y7roXdyqcdGDDtH9bfkWwg3tbToT
Next: 3MwyKmQGJwdXMNmMNTjrLsgPuwkah6Gzj7Hw7Qowc2Hj

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 keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
54 54  
55 55  
56 56  func valueWithdrawalRequest (status,lpAssetAmount,targetPeriod,claimTxId) = {
57 57      let claimTxIdStr =     match claimTxId {
58 58          case b: ByteVector => 
59 59              toBase58String(b)
60 60          case _: Unit => 
61 61              "SOON"
62 62          case _ => 
63 63              throw("Match error")
64 64      }
65 65      makeString(["%s%d%d%s", status, toString(lpAssetAmount), toString(targetPeriod), claimTxIdStr], SEP)
66 66      }
67 67  
68 68  
69 69  func parseWithdrawalRequestValueOrFail (s) = {
70 70      let parts = split(s, SEP)
71 71      if ((size(parts) == 5))
72 72          then {
73 73              let status = parts[1]
74 74              let lpAssetAmount = valueOrErrorMessage(parseInt(parts[2]), wrapErr("invalid lpAssetAmount"))
75 75              let targetPeriod = valueOrErrorMessage(parseInt(parts[3]), wrapErr("invalid targetPeriod"))
76 76              let claimTxId = parts[4]
77 77              $Tuple4(status, lpAssetAmount, targetPeriod, claimTxId)
78 78              }
79 79          else throwErr("invalid withdrawal request value")
80 80      }
81 81  
82 82  
83 83  let factoryAddressOption = match getString(this, keyFactoryAddress()) {
84 84      case s: String => 
85 85          addressFromString(s)
86 86      case _: Unit => 
87 87          unit
88 88      case _ => 
89 89          throw("Match error")
90 90  }
91 91  
92 92  let factoryAddressOrFail = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
93 93  
94 94  let lpAssetIdOption = match factoryAddressOption {
95 95      case a: Address => 
96 96          match getString(a, keyLpAssetId()) {
97 97              case s: String => 
98 98                  fromBase58String(s)
99 99              case _: Unit => 
100 100                  unit
101 101              case _ => 
102 102                  throw("Match error")
103 103          }
104 104      case _: Unit => 
105 105          unit
106 106      case _ => 
107 107          throw("Match error")
108 108  }
109 109  
110 110  let lpAssetIdOrFail = valueOrErrorMessage(lpAssetIdOption, wrapErr("invalid lpAssetId"))
111 111  
112 112  let treasuryAddressOption = match factoryAddressOption {
113 113      case a: Address => 
114 114          match getString(a, keyTreasuryAddress()) {
115 115              case s: String => 
116 116                  addressFromString(s)
117 117              case _: Unit => 
118 118                  unit
119 119              case _ => 
120 120                  throw("Match error")
121 121          }
122 122      case _: Unit => 
123 123          unit
124 124      case _ => 
125 125          throw("Match error")
126 126  }
127 127  
128 128  let treasuryAddressOrFail = valueOrErrorMessage(treasuryAddressOption, wrapErr("invalid treasury address"))
129 129  
130 130  func onlyAddress (i,address) = if ((i.caller == address))
131 131      then true
132 132      else throwErr("permission denied")
133 133  
134 134  
135 135  func onlyFactory (i) = onlyAddress(i, factoryAddressOrFail)
136 136  
137 137  
138 138  func rewardForOption (rewards,target) = {
139 139      let s = size(rewards)
140 140      let $t032473272 = rewards[0]
141 141      let a0 = $t032473272._1
142 142      let r0 = $t032473272._2
143 143      let $t032753300 = rewards[1]
144 144      let a1 = $t032753300._1
145 145      let r1 = $t032753300._2
146 146      let $t033033328 = rewards[2]
147 147      let a2 = $t033033328._1
148 148      let r2 = $t033033328._2
149 149      if (if ((s > 0))
150 150          then (a0 == target)
151 151          else false)
152 152          then r0
153 153          else if (if ((s > 1))
154 154              then (a1 == target)
155 155              else false)
156 156              then r1
157 157              else if (if ((s > 2))
158 158                  then (a2 == target)
159 159                  else false)
160 160                  then r2
161 161                  else unit
162 162      }
163 163  
164 164  
165 165  @Callable(i)
166 166  func claimLP (userAddressBytes) = {
167 167      let checkCaller = onlyFactory(i)
168 168      if ((checkCaller == checkCaller))
169 169          then {
170 170              let userAddress = Address(userAddressBytes)
171 171              let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
172 172              let claimed = valueOrElse(getInteger(factoryAddressOrFail, keyClaimed(userAddress)), 0)
173 173              let factoryActions = if ((available > 0))
174 174                  then [invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, available, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), 0], nil), invoke(factoryAddressOrFail, "stringEntry", [keyClaimed(userAddress), (claimed + available)], nil)]
175 175                  else nil
176 176              $Tuple2(nil, factoryActions)
177 177              }
178 178          else throw("Strict value is not equal to itself.")
179 179      }
180 180  
181 181  
182 182  
183 183  @Callable(i)
184 184  func finalize (newTreasuryVolumeInWaves,xtnPrice,pwrManagersBonus,treasuryVolumeDiffAllocationCoef) = {
185 185      let checks = [if ((i.originCaller == factoryAddressOrFail))
186 186          then true
187 187          else throwErr("permission denied"), if ((newTreasuryVolumeInWaves >= 0))
188 188          then true
189 189          else throwErr("invalid new treasury volume"), if ((xtnPrice >= 0))
190 190          then true
191 191          else throwErr("invalid XTN price"), if (if ((pwrManagersBonus >= 0))
192 192          then (SCALE8 >= pwrManagersBonus)
193 193          else false)
194 194          then true
195 195          else throwErr("invalid PWR managers bonus"), if (if ((treasuryVolumeDiffAllocationCoef >= -(SCALE8)))
196 196          then (SCALE8 >= treasuryVolumeDiffAllocationCoef)
197 197          else false)
198 198          then true
199 199          else throwErr("invalid treasury volume diff allocation coefficient")]
200 200      if ((checks == checks))
201 201          then {
202 202              let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
203 203              let newPeriod = (currentPeriodOrFail + 1)
204 204              let newPrice = SCALE8
205 205              let lpAssetAmountToBurn = 0
206 206              let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyCurrentPeriod(), newPeriod], nil), invoke(factoryAddressOrFail, "integerEntry", [keyPriceForPeriod(newPeriod), newPrice], nil), invoke(factoryAddressOrFail, "burn", [lpAssetAmountToBurn], nil)]
207 207              $Tuple2(nil, factoryActions)
208 208              }
209 209          else throw("Strict value is not equal to itself.")
210 210      }
211 211  
212 212  
213 213  
214 214  @Callable(i)
215 215  func invest (userAddressBytes) = {
216 216      let checkCaller = onlyFactory(i)
217 217      if ((checkCaller == checkCaller))
218 218          then {
219 219              let userAddress = Address(userAddressBytes)
220 220              let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
221 221              let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
222 222              let payment = if ((size(i.payments) == 1))
223 223                  then i.payments[0]
224 224                  else throwErr("invalid payments")
225 225              let paymentAmount = if (if ((payment.assetId == unit))
226 226                  then (payment.amount > 0)
227 227                  else false)
228 228                  then payment.amount
229 229                  else throwErr("invalid payment amount")
230 230              let lpAssetAmount = if ((currentPriceOrFail > 0))
231 231                  then fraction(paymentAmount, SCALE8, currentPriceOrFail)
232 232                  else 0
233 233              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 234              $Tuple2(nil, factoryActions)
235 235              }
236 236          else throw("Strict value is not equal to itself.")
237 237      }
238 238  
239 239  
240 240  
241 241  @Callable(i)
242 242  func withdraw (userAddressBytes) = {
243 243      let checkCaller = onlyFactory(i)
244 244      if ((checkCaller == checkCaller))
245 245          then {
246 246              let userAddress = Address(userAddressBytes)
247 247              let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
248 248              let payment = if ((size(i.payments) == 1))
249 249                  then i.payments[0]
250 250                  else throwErr(wrapErr("invalid payments"))
251 251              let paymentAssetId = if ((payment.assetId == lpAssetIdOrFail))
252 252                  then lpAssetIdOrFail
253 253                  else throwErr("invalid payment asset")
254 254              let paymentAmount = if ((payment.amount > 0))
255 255                  then payment.amount
256 256                  else throwErr("invalid payment amount")
257 257              let factoryActions = [invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, i.transactionId), valueWithdrawalRequest(PENDING, paymentAmount, (currentPeriodOrFail + 1), unit)], nil)]
258 258              if ((factoryActions == factoryActions))
259 259                  then $Tuple2([ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)], factoryActions)
260 260                  else throw("Strict value is not equal to itself.")
261 261              }
262 262          else throw("Strict value is not equal to itself.")
263 263      }
264 264  
265 265  
266 266  
267 267  @Callable(i)
268 268  func cancelWithdraw (userAddressBytes,txId) = {
269 269      let checkCaller = onlyFactory(i)
270 270      if ((checkCaller == checkCaller))
271 271          then {
272 272              let userAddress = Address(userAddressBytes)
273 273              let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
274 274              let $t085528665 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
275 275              let status = $t085528665._1
276 276              let lpAssetAmount = $t085528665._2
277 277              let targetPeriod = $t085528665._3
278 278              let claimTxId = $t085528665._4
279 279              if ((status == PENDING))
280 280                  then {
281 281                      let factoryActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
282 282                      if ((factoryActions == factoryActions))
283 283                          then $Tuple2(nil, factoryActions)
284 284                          else throw("Strict value is not equal to itself.")
285 285                      }
286 286                  else throwErr("invalid withdrawal request status")
287 287              }
288 288          else throw("Strict value is not equal to itself.")
289 289      }
290 290  
291 291  
292 292  
293 293  @Callable(i)
294 294  func claimWaves (userAddressBytes,txId) = {
295 295      let checkCaller = onlyFactory(i)
296 296      if ((checkCaller == checkCaller))
297 297          then {
298 298              let userAddress = Address(userAddressBytes)
299 299              let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
300 300              let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
301 301              let $t095369649 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
302 302              let status = $t095369649._1
303 303              let lpAssetAmount = $t095369649._2
304 304              let targetPeriod = $t095369649._3
305 305              let claimTxId = $t095369649._4
306 306              if ((status == FINISHED))
307 307                  then throwErr("invalid withdrawal request status")
308 308                  else if ((targetPeriod > currentPeriodOrFail))
309 309                      then throwErr("invalid withdrawal request period")
310 310                      else {
311 311                          let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
312 312                          let amount = if ((currentPriceOrFail > 0))
313 313                              then fraction(lpAssetAmount, currentPriceOrFail, SCALE8)
314 314                              else 0
315 315                          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 316                          $Tuple2(nil, factoryActions)
317 317                          }
318 318              }
319 319          else throw("Strict value is not equal to itself.")
320 320      }
321 321  
322 322  
323 323  
324 324  @Callable(i)
325 325  func processBlocks (userAddressBytes) = {
326 326      let checkCaller = onlyFactory(i)
327 327      if ((checkCaller == checkCaller))
328 328          then {
329 329              let userAddress = Address(userAddressBytes)
330 330              let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
331 331              let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
332 332              let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
333 333              let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
334 334              let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
335 335              let targetBlockInfo = if (if (if ((height >= nextBlockToProcess))
336 336                  then if ((nextBlockToProcess >= currentStartHeight))
337 337                      then true
338 338                      else (currentPeriodOrFail == 0)
339 339                  else false)
340 340                  then ((currentStartHeight + periodLength) > nextBlockToProcess)
341 341                  else false)
342 342                  then valueOrErrorMessage(blockInfoByHeight(nextBlockToProcess), wrapErr("invalid block info"))
343 343                  else throwErr(wrapErr("invalid target block"))
344 344              let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, treasuryAddressOrFail), wrapErr("invalid treasury reward"))
345 345              let blockProcessingRewardOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
346 346              let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
347 347              let lpAssetAmount = if ((currentPriceOrFail > 0))
348 348                  then fraction((treasuryRewardOrFail - blockProcessingRewardOrFail), SCALE8, currentPriceOrFail)
349 349                  else 0
350 350              let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + 1)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), available], nil), invoke(factoryAddressOrFail, "transferWaves", [userAddressBytes, blockProcessingRewardOrFail], nil)]
351 351              $Tuple2(nil, factoryActions)
352 352              }
353 353          else throw("Strict value is not equal to itself.")
354 354      }
355 355  
356 356  
357 357  @Verifier(tx)
358 358  func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
359 359

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 keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
54	54
55	55
56	56	func valueWithdrawalRequest (status,lpAssetAmount,targetPeriod,claimTxId) = {
57	57	let claimTxIdStr = match claimTxId {
58	58	case b: ByteVector =>
59	59	toBase58String(b)
60	60	case _: Unit =>
61	61	"SOON"
62	62	case _ =>
63	63	throw("Match error")
64	64	}
65	65	makeString(["%s%d%d%s", status, toString(lpAssetAmount), toString(targetPeriod), claimTxIdStr], SEP)
66	66	}
67	67
68	68
69	69	func parseWithdrawalRequestValueOrFail (s) = {
70	70	let parts = split(s, SEP)
71	71	if ((size(parts) == 5))
72	72	then {
73	73	let status = parts[1]
74	74	let lpAssetAmount = valueOrErrorMessage(parseInt(parts[2]), wrapErr("invalid lpAssetAmount"))
75	75	let targetPeriod = valueOrErrorMessage(parseInt(parts[3]), wrapErr("invalid targetPeriod"))
76	76	let claimTxId = parts[4]
77	77	$Tuple4(status, lpAssetAmount, targetPeriod, claimTxId)
78	78	}
79	79	else throwErr("invalid withdrawal request value")
80	80	}
81	81
82	82
83	83	let factoryAddressOption = match getString(this, keyFactoryAddress()) {
84	84	case s: String =>
85	85	addressFromString(s)
86	86	case _: Unit =>
87	87	unit
88	88	case _ =>
89	89	throw("Match error")
90	90	}
91	91
92	92	let factoryAddressOrFail = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
93	93
94	94	let lpAssetIdOption = match factoryAddressOption {
95	95	case a: Address =>
96	96	match getString(a, keyLpAssetId()) {
97	97	case s: String =>
98	98	fromBase58String(s)
99	99	case _: Unit =>
100	100	unit
101	101	case _ =>
102	102	throw("Match error")
103	103	}
104	104	case _: Unit =>
105	105	unit
106	106	case _ =>
107	107	throw("Match error")
108	108	}
109	109
110	110	let lpAssetIdOrFail = valueOrErrorMessage(lpAssetIdOption, wrapErr("invalid lpAssetId"))
111	111
112	112	let treasuryAddressOption = match factoryAddressOption {
113	113	case a: Address =>
114	114	match getString(a, keyTreasuryAddress()) {
115	115	case s: String =>
116	116	addressFromString(s)
117	117	case _: Unit =>
118	118	unit
119	119	case _ =>
120	120	throw("Match error")
121	121	}
122	122	case _: Unit =>
123	123	unit
124	124	case _ =>
125	125	throw("Match error")
126	126	}
127	127
128	128	let treasuryAddressOrFail = valueOrErrorMessage(treasuryAddressOption, wrapErr("invalid treasury address"))
129	129
130	130	func onlyAddress (i,address) = if ((i.caller == address))
131	131	then true
132	132	else throwErr("permission denied")
133	133
134	134
135	135	func onlyFactory (i) = onlyAddress(i, factoryAddressOrFail)
136	136
137	137
138	138	func rewardForOption (rewards,target) = {
139	139	let s = size(rewards)
140	140	let $t032473272 = rewards[0]
141	141	let a0 = $t032473272._1
142	142	let r0 = $t032473272._2
143	143	let $t032753300 = rewards[1]
144	144	let a1 = $t032753300._1
145	145	let r1 = $t032753300._2
146	146	let $t033033328 = rewards[2]
147	147	let a2 = $t033033328._1
148	148	let r2 = $t033033328._2
149	149	if (if ((s > 0))
150	150	then (a0 == target)
151	151	else false)
152	152	then r0
153	153	else if (if ((s > 1))
154	154	then (a1 == target)
155	155	else false)
156	156	then r1
157	157	else if (if ((s > 2))
158	158	then (a2 == target)
159	159	else false)
160	160	then r2
161	161	else unit
162	162	}
163	163
164	164
165	165	@Callable(i)
166	166	func claimLP (userAddressBytes) = {
167	167	let checkCaller = onlyFactory(i)
168	168	if ((checkCaller == checkCaller))
169	169	then {
170	170	let userAddress = Address(userAddressBytes)
171	171	let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
172	172	let claimed = valueOrElse(getInteger(factoryAddressOrFail, keyClaimed(userAddress)), 0)
173	173	let factoryActions = if ((available > 0))
174	174	then [invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, available, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), 0], nil), invoke(factoryAddressOrFail, "stringEntry", [keyClaimed(userAddress), (claimed + available)], nil)]
175	175	else nil
176	176	$Tuple2(nil, factoryActions)
177	177	}
178	178	else throw("Strict value is not equal to itself.")
179	179	}
180	180
181	181
182	182
183	183	@Callable(i)
184	184	func finalize (newTreasuryVolumeInWaves,xtnPrice,pwrManagersBonus,treasuryVolumeDiffAllocationCoef) = {
185	185	let checks = [if ((i.originCaller == factoryAddressOrFail))
186	186	then true
187	187	else throwErr("permission denied"), if ((newTreasuryVolumeInWaves >= 0))
188	188	then true
189	189	else throwErr("invalid new treasury volume"), if ((xtnPrice >= 0))
190	190	then true
191	191	else throwErr("invalid XTN price"), if (if ((pwrManagersBonus >= 0))
192	192	then (SCALE8 >= pwrManagersBonus)
193	193	else false)
194	194	then true
195	195	else throwErr("invalid PWR managers bonus"), if (if ((treasuryVolumeDiffAllocationCoef >= -(SCALE8)))
196	196	then (SCALE8 >= treasuryVolumeDiffAllocationCoef)
197	197	else false)
198	198	then true
199	199	else throwErr("invalid treasury volume diff allocation coefficient")]
200	200	if ((checks == checks))
201	201	then {
202	202	let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
203	203	let newPeriod = (currentPeriodOrFail + 1)
204	204	let newPrice = SCALE8
205	205	let lpAssetAmountToBurn = 0
206	206	let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyCurrentPeriod(), newPeriod], nil), invoke(factoryAddressOrFail, "integerEntry", [keyPriceForPeriod(newPeriod), newPrice], nil), invoke(factoryAddressOrFail, "burn", [lpAssetAmountToBurn], nil)]
207	207	$Tuple2(nil, factoryActions)
208	208	}
209	209	else throw("Strict value is not equal to itself.")
210	210	}
211	211
212	212
213	213
214	214	@Callable(i)
215	215	func invest (userAddressBytes) = {
216	216	let checkCaller = onlyFactory(i)
217	217	if ((checkCaller == checkCaller))
218	218	then {
219	219	let userAddress = Address(userAddressBytes)
220	220	let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
221	221	let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
222	222	let payment = if ((size(i.payments) == 1))
223	223	then i.payments[0]
224	224	else throwErr("invalid payments")
225	225	let paymentAmount = if (if ((payment.assetId == unit))
226	226	then (payment.amount > 0)
227	227	else false)
228	228	then payment.amount
229	229	else throwErr("invalid payment amount")
230	230	let lpAssetAmount = if ((currentPriceOrFail > 0))
231	231	then fraction(paymentAmount, SCALE8, currentPriceOrFail)
232	232	else 0
233	233	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	234	$Tuple2(nil, factoryActions)
235	235	}
236	236	else throw("Strict value is not equal to itself.")
237	237	}
238	238
239	239
240	240
241	241	@Callable(i)
242	242	func withdraw (userAddressBytes) = {
243	243	let checkCaller = onlyFactory(i)
244	244	if ((checkCaller == checkCaller))
245	245	then {
246	246	let userAddress = Address(userAddressBytes)
247	247	let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
248	248	let payment = if ((size(i.payments) == 1))
249	249	then i.payments[0]
250	250	else throwErr(wrapErr("invalid payments"))
251	251	let paymentAssetId = if ((payment.assetId == lpAssetIdOrFail))
252	252	then lpAssetIdOrFail
253	253	else throwErr("invalid payment asset")
254	254	let paymentAmount = if ((payment.amount > 0))
255	255	then payment.amount
256	256	else throwErr("invalid payment amount")
257	257	let factoryActions = [invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, i.transactionId), valueWithdrawalRequest(PENDING, paymentAmount, (currentPeriodOrFail + 1), unit)], nil)]
258	258	if ((factoryActions == factoryActions))
259	259	then $Tuple2([ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)], factoryActions)
260	260	else throw("Strict value is not equal to itself.")
261	261	}
262	262	else throw("Strict value is not equal to itself.")
263	263	}
264	264
265	265
266	266
267	267	@Callable(i)
268	268	func cancelWithdraw (userAddressBytes,txId) = {
269	269	let checkCaller = onlyFactory(i)
270	270	if ((checkCaller == checkCaller))
271	271	then {
272	272	let userAddress = Address(userAddressBytes)
273	273	let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
274	274	let $t085528665 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
275	275	let status = $t085528665._1
276	276	let lpAssetAmount = $t085528665._2
277	277	let targetPeriod = $t085528665._3
278	278	let claimTxId = $t085528665._4
279	279	if ((status == PENDING))
280	280	then {
281	281	let factoryActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
282	282	if ((factoryActions == factoryActions))
283	283	then $Tuple2(nil, factoryActions)
284	284	else throw("Strict value is not equal to itself.")
285	285	}
286	286	else throwErr("invalid withdrawal request status")
287	287	}
288	288	else throw("Strict value is not equal to itself.")
289	289	}
290	290
291	291
292	292
293	293	@Callable(i)
294	294	func claimWaves (userAddressBytes,txId) = {
295	295	let checkCaller = onlyFactory(i)
296	296	if ((checkCaller == checkCaller))
297	297	then {
298	298	let userAddress = Address(userAddressBytes)
299	299	let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
300	300	let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
301	301	let $t095369649 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
302	302	let status = $t095369649._1
303	303	let lpAssetAmount = $t095369649._2
304	304	let targetPeriod = $t095369649._3
305	305	let claimTxId = $t095369649._4
306	306	if ((status == FINISHED))
307	307	then throwErr("invalid withdrawal request status")
308	308	else if ((targetPeriod > currentPeriodOrFail))
309	309	then throwErr("invalid withdrawal request period")
310	310	else {
311	311	let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
312	312	let amount = if ((currentPriceOrFail > 0))
313	313	then fraction(lpAssetAmount, currentPriceOrFail, SCALE8)
314	314	else 0
315	315	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	316	$Tuple2(nil, factoryActions)
317	317	}
318	318	}
319	319	else throw("Strict value is not equal to itself.")
320	320	}
321	321
322	322
323	323
324	324	@Callable(i)
325	325	func processBlocks (userAddressBytes) = {
326	326	let checkCaller = onlyFactory(i)
327	327	if ((checkCaller == checkCaller))
328	328	then {
329	329	let userAddress = Address(userAddressBytes)
330	330	let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
331	331	let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
332	332	let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
333	333	let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
334	334	let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
335	335	let targetBlockInfo = if (if (if ((height >= nextBlockToProcess))
336	336	then if ((nextBlockToProcess >= currentStartHeight))
337	337	then true
338	338	else (currentPeriodOrFail == 0)
339	339	else false)
340	340	then ((currentStartHeight + periodLength) > nextBlockToProcess)
341	341	else false)
342	342	then valueOrErrorMessage(blockInfoByHeight(nextBlockToProcess), wrapErr("invalid block info"))
343	343	else throwErr(wrapErr("invalid target block"))
344	344	let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, treasuryAddressOrFail), wrapErr("invalid treasury reward"))
345	345	let blockProcessingRewardOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
346	346	let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
347	347	let lpAssetAmount = if ((currentPriceOrFail > 0))
348	348	then fraction((treasuryRewardOrFail - blockProcessingRewardOrFail), SCALE8, currentPriceOrFail)
349	349	else 0
350	350	let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + 1)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), available], nil), invoke(factoryAddressOrFail, "transferWaves", [userAddressBytes, blockProcessingRewardOrFail], nil)]
351	351	$Tuple2(nil, factoryActions)
352	352	}
353	353	else throw("Strict value is not equal to itself.")
354	354	}
355	355
356	356
357	357	@Verifier(tx)
358	358	func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
359	359

github/deemru/w8io/169f3d6 
140.66 ms ◑