w8 · tx · 98Z···uLS

tx · 98ZUVjDaiPWp71DQnBEQ9aicCu5DqRWQiE6FhBvtBuLS

3MudYAdb2aRxJGx7YHraAtN7v6dXCVHUFKx:  -0.04500000 Waves

2023.08.07 13:05 [2700029] smart account 3MudYAdb2aRxJGx7YHraAtN7v6dXCVHUFKx > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "98ZUVjDaiPWp71DQnBEQ9aicCu5DqRWQiE6FhBvtBuLS",
    "fee": 4500000,
    "feeAssetId": null,
    "timestamp": 1691402826001,
    "version": 2,
    "chainId": 84,
    "sender": "3MudYAdb2aRxJGx7YHraAtN7v6dXCVHUFKx",
    "senderPublicKey": "FGk4k1DFjx16u4CWSy96FFccU9X7X6Q4sw1NhmDv3Vr4",
    "proofs": [
        "5cApvWhbexyS7fHQby7LiqwpEoT3p7JX5F8KyQeJHm1gNri99eAwV6fwJhJ3Z98YXFcZTqNcSd1xsLXcbcBD4SkB",
        "62wYMrsb3xNHZv6KmmeCBn4Dw1G3Gtkg7wJhbW9Rs7FtX4HWAxTxLAHTN9etsZs9qqjoGrUGTGQN355Gqp4PYbe2"
    ],
    "script": "base64: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",
    "height": 2700029,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GtyEW4kTgYB5RNo65QhbodL8E3HfUgtbsjM8mfMtRZxW
Next: Ah2TwbVLgDyvgvXroG4QKQaLDcQgyioyp7Wtsm1AFGpX

Diff: 
Old New Differences
186 186                                          else throw(($getType(aE) + " couldn't be cast to (Int, Int, Int, Int, Int)"))
187 187                                      }
188 188                                  if ((aD == aD))
189 -                                     then aD
189 +                                     then aD._2
190 190                                      else throw("Strict value is not equal to itself.")
191 191                                  }
192 192                              else 0
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let a = "1.0.0"
5 5  
6 6  let b = "version"
7 7  
8 8  let c = "active"
9 9  
10 10  let d = "deprecated_"
11 11  
12 12  let e = "A_asset_id"
13 13  
14 14  let f = "B_asset_id"
15 15  
16 16  let g = "A_asset_balance"
17 17  
18 18  let h = "B_asset_balance"
19 19  
20 20  let i = "A_asset_init"
21 21  
22 22  let j = "B_asset_init"
23 23  
24 24  let k = "share_asset_id"
25 25  
26 26  let l = "share_asset_supply"
27 27  
28 28  let m = "commission"
29 29  
30 30  let n = "shutdown_cause"
31 31  
32 32  let o = "first_harvest"
33 33  
34 34  let p = "first_harvest_height"
35 35  
36 36  let q = "share_limit_on_first_harvest"
37 37  
38 38  let r = "base_period"
39 39  
40 40  let s = "period_length"
41 41  
42 42  let t = "start_height"
43 43  
44 44  let u = "staking_usdnnsbt_address"
45 45  
46 46  let v = "staking_eurn_address"
47 47  
48 48  let w = "leasing_amount"
49 49  
50 50  let x = "usdn_asset_id"
51 51  
52 52  let y = "eurn_asset_id"
53 53  
54 54  let z = "l2mp_asset_id"
55 55  
56 56  let A = "staking_assets"
57 57  
58 58  let B = "active_all_contracts"
59 59  
60 60  let C = "discounts"
61 61  
62 62  let D = "discount_values"
63 63  
64 64  let E = "_GSwop_amount"
65 65  
66 66  let F = "_SWOP_amount"
67 67  
68 68  let G = "pool_"
69 69  
70 70  let H = "admin_pub_1"
71 71  
72 72  let I = "admin_pub_2"
73 73  
74 74  let J = "admin_pub_3"
75 75  
76 76  let K = "admin_invoke_pub"
77 77  
78 78  let L = "money_box_address"
79 79  
80 80  let M = "team_box_address"
81 81  
82 82  let N = "voting_address"
83 83  
84 84  let O = "governance_address"
85 85  
86 86  let P = "farming_address"
87 87  
88 88  let Q = "staking_l2mp_address"
89 89  
90 90  let R = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
91 91  
92 92  func S (T) = {
93 93      let U = getString(R, T)
94 94      if ($isInstanceOf(U, "String"))
95 95          then {
96 96              let V = U
97 97              fromBase58String(V)
98 98              }
99 99          else {
100 100              let W = U
101 101              throw((T + "is empty"))
102 102              }
103 103      }
104 104  
105 105  
106 106  let X = S(H)
107 107  
108 108  let Y = S(I)
109 109  
110 110  let Z = S(J)
111 111  
112 112  let aa = S(K)
113 113  
114 114  let ab = Address(S(L))
115 115  
116 116  let ac = Address(S(M))
117 117  
118 118  let ad = Address(S(N))
119 119  
120 120  let ae = Address(S(O))
121 121  
122 122  let af = Address(S(P))
123 123  
124 124  let ag = S(x)
125 125  
126 126  let ah = S(y)
127 127  
128 128  let ai = S(z)
129 129  
130 130  let aj = getStringValue(R, A)
131 131  
132 132  let ak = Address(S(u))
133 133  
134 134  let al = Address(S(v))
135 135  
136 136  let am = Address(S(Q))
137 137  
138 138  let an = valueOrErrorMessage(getInteger(ad, r), "Empty kBasePeriod")
139 139  
140 140  let ao = valueOrErrorMessage(getInteger(ad, t), "Empty kStartHeight")
141 141  
142 142  let ap = valueOrErrorMessage(getInteger(ad, s), "Empty kPeriodLength")
143 143  
144 144  let aq = ((an + ((height - ao) / ap)) + 3)
145 145  
146 146  let ar = getBooleanValue(R, B)
147 147  
148 148  let as = 1000000
149 149  
150 150  let at = 100000000
151 151  
152 152  let au = toBigInt(10000000000000000)
153 153  
154 154  func av (aw,ax) = {
155 155      let U = aw
156 156      if ($isInstanceOf(U, "ByteVector"))
157 157          then {
158 158              let ay = U
159 159              assetBalance(ax, ay)
160 160              }
161 161          else if ($isInstanceOf(U, "Unit"))
162 162              then {
163 163                  let az = U
164 164                  wavesBalance(ax).available
165 165                  }
166 166              else throw("Match error")
167 167      }
168 168  
169 169  
170 170  func aA (aw,ax) = {
171 171      let aB = {
172 172          let U = aw
173 173          if ($isInstanceOf(U, "ByteVector"))
174 174              then {
175 175                  let aC = U
176 176                  if ((aC == ag))
177 177                      then getInteger(ak, ((("rpd_balance_" + toBase58String(aC)) + "_") + toString(ax)))
178 178                      else if ((aC == ah))
179 179                          then getInteger(al, ((("%s%s%s__stakingBalance__" + toBase58String(aC)) + "__") + toString(ax)))
180 180                          else if ((aC == ai))
181 181                              then {
182 182                                  let aD = {
183 183                                      let aE = invoke(am, "getUserAssetsREADONLY", [ax], nil)
184 184                                      if ($isInstanceOf(aE, "(Int, Int, Int, Int, Int)"))
185 185                                          then aE
186 186                                          else throw(($getType(aE) + " couldn't be cast to (Int, Int, Int, Int, Int)"))
187 187                                      }
188 188                                  if ((aD == aD))
189 -                                     then aD
189 +                                     then aD._2
190 190                                      else throw("Strict value is not equal to itself.")
191 191                                  }
192 192                              else 0
193 193                  }
194 194              else if ($isInstanceOf(U, "Unit"))
195 195                  then valueOrElse(getInteger(ax, w), 0)
196 196                  else throw("Match error")
197 197          }
198 198      let U = aB
199 199      if ($isInstanceOf(U, "Int"))
200 200          then {
201 201              let aF = U
202 202              aF
203 203              }
204 204          else 0
205 205      }
206 206  
207 207  
208 208  func aG (aw) = {
209 209      let U = aw
210 210      if (if ($isInstanceOf(U, "String"))
211 211          then true
212 212          else $isInstanceOf(U, "ByteVector"))
213 213          then {
214 214              let ay = U
215 215              let aH = {
216 216                  let aI = ay
217 217                  if ($isInstanceOf(aI, "ByteVector"))
218 218                      then {
219 219                          let aC = aI
220 220                          $Tuple2(toBase58String(aC), aC)
221 221                          }
222 222                      else if ($isInstanceOf(aI, "String"))
223 223                          then {
224 224                              let aC = aI
225 225                              $Tuple2(aC, fromBase58String(aC))
226 226                              }
227 227                          else throw("Match error")
228 228                  }
229 229              let aJ = aH._1
230 230              let aK = aH._2
231 231              let aL = valueOrErrorMessage(assetInfo(aK), (("Asset " + aJ) + " doesn't exist"))
232 232              $Tuple3(aJ, aL.name, aL.decimals)
233 233              }
234 234          else if ($isInstanceOf(U, "Unit"))
235 235              then {
236 236                  let az = U
237 237                  $Tuple3("WAVES", "WAVES", 8)
238 238                  }
239 239              else throw("Match error")
240 240      }
241 241  
242 242  
243 243  func aM (aN) = [BooleanEntry(c, false), StringEntry(n, aN)]
244 244  
245 245  
246 246  func aO (aP) = {
247 247      let aQ = valueOrElse(getInteger(ae, (toString(aP) + F)), 0)
248 248      let aR = valueOrElse(getInteger(ae, (toString(aP) + E)), aQ)
249 249      let aS = split(getStringValue(R, D), ",")
250 250      let aT = split(getStringValue(R, C), ",")
251 251      if (if ((aR >= parseIntValue(aS[0])))
252 252          then (parseIntValue(aS[1]) > aR)
253 253          else false)
254 254          then (as - parseIntValue(aT[0]))
255 255          else if (if ((aR >= parseIntValue(aS[1])))
256 256              then (parseIntValue(aS[2]) > aR)
257 257              else false)
258 258              then (as - parseIntValue(aT[1]))
259 259              else if (if ((aR >= parseIntValue(aS[2])))
260 260                  then (parseIntValue(aS[3]) > aR)
261 261                  else false)
262 262                  then (as - parseIntValue(aT[2]))
263 263                  else if (if ((aR >= parseIntValue(aS[3])))
264 264                      then (parseIntValue(aS[4]) > aR)
265 265                      else false)
266 266                      then (as - parseIntValue(aT[3]))
267 267                      else if ((aR >= parseIntValue(aS[4])))
268 268                          then (as - parseIntValue(aT[4]))
269 269                          else as
270 270      }
271 271  
272 272  
273 273  func aU (aV,aW,aX,aY,aZ,ba,bb) = {
274 274      let bc = fraction(aY, aV, (aV + aX))
275 275      let bd = fraction(bc, (as - aZ), as)
276 276      let be = fraction(bc, ba, as)
277 277      let bf = fraction(bc, bb, as)
278 278      if ((aW > bd))
279 279          then throw(((("Calculated amount to receive " + toString(bd)) + " is less than specified minimum ") + toString(aW)))
280 280          else $Tuple4(bc, bd, be, bf)
281 281      }
282 282  
283 283  
284 284  func bg (aV,bh,aZ) = {
285 285      let bi = (as - aZ)
286 286      let bj = fraction(aZ, 55, 100)
287 287      let bk = (at + fraction((bi * bj), at, (as * as)))
288 288      let bl = ((((bh + fraction(bh, bi, as)) + fraction(aV, bi, as)) - aV) - fraction(aV, (bi * bj), (as * as)))
289 289      let bm = (-(toBigInt(bh)) * toBigInt(aV))
290 290      let bn = ((toBigInt(bl) * toBigInt(bl)) - fraction((toBigInt(4) * bm), toBigInt(bk), toBigInt(at)))
291 291      toInt(fraction((-(toBigInt(bl)) + sqrtBigInt(bn, 0, 0, DOWN)), toBigInt(at), toBigInt((2 * bk))))
292 292      }
293 293  
294 294  
295 295  func bo (aw) = if ((aw == base58''))
296 296      then unit
297 297      else aw
298 298  
299 299  
300 300  func bp (bq,br,bs,bt,bu,bv) = aM(((((((((((((((("Suspicious state. Actual balances: " + toString(bq)) + " ") + bu) + ", ") + toString(br)) + " ") + bv) + ". State: ") + toString(bs)) + " ") + bu) + ", ") + toString(bt)) + " ") + bv))
301 301  
302 302  
303 303  func bw () = if (ar)
304 304      then unit
305 305      else throw("DApp is inactive at this moment")
306 306  
307 307  
308 308  func bx (by) = if (isDefined(getString(R, (G + by))))
309 309      then unit
310 310      else throw("DApp is not registered pool")
311 311  
312 312  
313 313  func bz (by) = if (!(valueOrElse(getBoolean(R, (d + by)), false)))
314 314      then unit
315 315      else throw("Pool is deprecated. Only withdraw action allowed.")
316 316  
317 317  
318 318  func bA (ax,bu,bv) = {
319 319      let bs = getIntegerValue(ax, g)
320 320      let bt = getIntegerValue(ax, h)
321 321      let bB = aA(bu, ax)
322 322      let bC = aA(bv, ax)
323 323      let bq = (av(bu, ax) + bB)
324 324      let br = (av(bv, ax) + bC)
325 325      $Tuple6(bs, bt, bq, br, bB, bC)
326 326      }
327 327  
328 328  
329 329  func bD (ax) = getIntegerValue(ax, l)
330 330  
331 331  
332 332  func bE (ax) = {
333 333      let bF = getStringValue(ax, e)
334 334      let bG = getStringValue(ax, f)
335 335      let bu = if ((bF == "WAVES"))
336 336          then unit
337 337          else fromBase58String(bF)
338 338      let bv = if ((bG == "WAVES"))
339 339          then unit
340 340          else fromBase58String(bG)
341 341      let bH = fromBase58String(getStringValue(ax, k))
342 342      $Tuple5(bF, bG, bu, bv, bH)
343 343      }
344 344  
345 345  
346 346  func bI (ax,bJ) = {
347 347      let bK = aO(bJ)
348 348      let aZ = fraction(getIntegerValue(ax, m), bK, as, CEILING)
349 349      let bL = fraction(aZ, 35, 100)
350 350      let bM = fraction(aZ, 10, 100)
351 351      $Tuple3(aZ, bL, bM)
352 352      }
353 353  
354 354  
355 355  func bN (bO,bP,bQ,bR,bS,bT,bU) = {
356 356      let bV = aG(bQ)
357 357      let bW = bV._1
358 358      let bX = bV._2
359 359      let bY = bV._3
360 360      let bZ = aG(bR)
361 361      let ca = bZ._1
362 362      let cb = bZ._2
363 363      let cc = bZ._3
364 364      let cd = ((bS + bT) == 0)
365 365      let ce = if (cd)
366 366          then $Tuple5(bO, bP, 0, bQ, toBigInt(1))
367 367          else {
368 368              let cf = fraction(au, toBigInt(bO), toBigInt(bS))
369 369              let cg = fraction(au, toBigInt(bP), toBigInt(bT))
370 370              if ((cg > cf))
371 371                  then {
372 372                      let ch = fraction(bO, bT, bS)
373 373                      $Tuple5(bO, ch, (bP - ch), bR, cf)
374 374                      }
375 375                  else {
376 376                      let ch = fraction(bP, bS, bT)
377 377                      $Tuple5(ch, bP, (bO - ch), bQ, cg)
378 378                      }
379 379              }
380 380      let ci = ce._1
381 381      let cj = ce._2
382 382      let ck = ce._3
383 383      let cl = ce._4
384 384      let cm = ce._5
385 385      let cn = if (cd)
386 386          then {
387 387              let co = ((bY + cc) / 2)
388 388              fraction(pow(ci, bY, 5, 1, bY, DOWN), pow(cj, cc, 5, 1, cc, DOWN), pow(10, 0, co, 0, 0, DOWN))
389 389              }
390 390          else toInt(fraction(cm, toBigInt(bU), au))
391 391      $Tuple5(cn, ck, cl, ci, cj)
392 392      }
393 393  
394 394  
395 395  func cp (aV,cq,aC,cr,bS,bT,cs,aZ,bL,bM,ct) = if ((cq == aC))
396 396      then {
397 397          let cu = bg(aV, bS, aZ)
398 398          let cv = aU(cu, ct, bS, bT, aZ, bL, bM)
399 399          let bc = cv._1
400 400          let bd = cv._2
401 401          let be = cv._3
402 402          let cw = cv._4
403 403          let cx = (bS + cu)
404 404          let cy = (((bT + bc) - be) - cw)
405 405          let cz = (bS + aV)
406 406          let cA = ((bT - be) - cw)
407 407          let cf = fraction(toBigInt((aV - cu)), au, toBigInt(cx))
408 408          let cg = fraction(toBigInt(bd), au, toBigInt(cy))
409 409          let cn = toInt(fraction(min([cf, cg]), toBigInt(cs), au))
410 410          let cB = toInt(fraction(fraction(toBigInt((aV - cu)), au, toBigInt(bS)), toBigInt(cs), au))
411 411          let cC = fraction((cn - cB), at, cB)
412 412          $Tuple7(cn, cz, cA, be, cw, cr, cC)
413 413          }
414 414      else {
415 415          let cu = bg(aV, bT, aZ)
416 416          let cD = aU(cu, ct, bT, bS, aZ, bL, bM)
417 417          let bc = cD._1
418 418          let bd = cD._2
419 419          let be = cD._3
420 420          let cw = cD._4
421 421          let cx = (((bS + bc) - be) - cw)
422 422          let cy = (bT + cu)
423 423          let cz = ((bS - be) - cw)
424 424          let cA = (bT + aV)
425 425          let cf = fraction(toBigInt(bd), au, toBigInt(cx))
426 426          let cg = fraction(toBigInt((aV - cu)), au, toBigInt(cy))
427 427          let cn = toInt(fraction(min([cf, cg]), toBigInt(cs), au))
428 428          let cB = toInt(fraction(fraction(toBigInt((aV - cu)), au, toBigInt(bT)), toBigInt(cs), au))
429 429          let cC = fraction((cn - cB), at, cB)
430 430          $Tuple7(cn, cz, cA, be, cw, aC, cC)
431 431          }
432 432  
433 433  
434 434  func cE (bO,bP,bQ,bR,bS,bT,cs,aZ,bL,bM,ct) = {
435 435      let cF = bN(bO, bP, bQ, bR, bS, bT, cs)
436 436      let cG = cF._1
437 437      let ck = cF._2
438 438      let cl = cF._3
439 439      let ci = cF._4
440 440      let cj = cF._5
441 441      if ((ck > 0))
442 442          then {
443 443              let cH = cp(ck, cl, bQ, bR, (bS + ci), (bT + cj), cs, aZ, bL, bM, ct)
444 444              let cI = cH._1
445 445              let cz = cH._2
446 446              let cA = cH._3
447 447              let be = cH._4
448 448              let cw = cH._5
449 449              let cJ = cH._6
450 450              let cC = cH._7
451 451              $Tuple7((cG + cI), cC, cz, cA, be, cw, cJ)
452 452              }
453 453          else $Tuple7(cG, 0, (bS + ci), (bT + cj), 0, 0, unit)
454 454      }
455 455  
456 456  
457 457  @Callable(aF)
458 458  func calcLPReplenishDiffPropREADONLY (cK,cL,cM,cN) = {
459 459      let cO = bE(aF.caller)
460 460      let bF = cO._1
461 461      let bG = cO._2
462 462      let bu = cO._3
463 463      let bv = cO._4
464 464      let bH = cO._5
465 465      let cP = bA(aF.caller, bu, bv)
466 466      let bS = cP._1
467 467      let bT = cP._2
468 468      let cQ = cP._3
469 469      let cR = cP._4
470 470      let cs = bD(aF.caller)
471 471      let bO = parseIntValue(cL[0])
472 472      let bP = parseIntValue(cL[1])
473 473      let ct = parseIntValue(cL[2])
474 474      let cS = bI(aF.caller, aF.originCaller)
475 475      let aZ = cS._1
476 476      let bL = cS._2
477 477      let bM = cS._3
478 478      let cT = cE(bO, bP, bu, bv, bS, bT, cs, aZ, bL, bM, ct)
479 479      let cU = cT._1
480 480      let cC = cT._2
481 481      let cz = cT._3
482 482      let cA = cT._4
483 483      let be = cT._5
484 484      let cw = cT._6
485 485      let aC = cT._7
486 486      $Tuple2(nil, $Tuple2(nil, [cU, cC, cz, cA, be, cw, aC]))
487 487      }
488 488  
489 489  
490 490  
491 491  @Callable(aF)
492 492  func calcLPReplenishTwoTokensREADONLY (cK,cL,cM,cN) = {
493 493      let cV = bE(aF.caller)
494 494      let bF = cV._1
495 495      let bG = cV._2
496 496      let bu = cV._3
497 497      let bv = cV._4
498 498      let bH = cV._5
499 499      let cW = bA(aF.caller, bu, bv)
500 500      let bS = cW._1
501 501      let bT = cW._2
502 502      let cQ = cW._3
503 503      let cR = cW._4
504 504      let cs = bD(aF.caller)
505 505      let bO = parseIntValue(cL[0])
506 506      let bP = parseIntValue(cL[1])
507 507      let cX = bN(bO, bP, bu, bv, bS, bT, cs)
508 508      let cU = cX._1
509 509      let ck = cX._2
510 510      let cl = cX._3
511 511      let ci = cX._4
512 512      let cj = cX._5
513 513      $Tuple2(nil, $Tuple2(nil, [cU, ck, cl, ci, cj]))
514 514      }
515 515  
516 516  
517 517  
518 518  @Callable(aF)
519 519  func withdrawREADONLY (cK,cL,cM,cN) = {
520 520      let cY = bE(aF.caller)
521 521      let bF = cY._1
522 522      let bG = cY._2
523 523      let bu = cY._3
524 524      let bv = cY._4
525 525      let bH = cY._5
526 526      let cZ = bA(aF.caller, bu, bv)
527 527      let bs = cZ._1
528 528      let bt = cZ._2
529 529      let bq = cZ._3
530 530      let br = cZ._4
531 531      let bU = bD(aF.caller)
532 532      let da = parseIntValue(cL[0])
533 533      let db = if ((size(cL) == 3))
534 534          then $Tuple2(parseIntValue(cL[1]), parseIntValue(cL[2]))
535 535          else $Tuple2(bs, bt)
536 536      let bS = db._1
537 537      let bT = db._2
538 538      let dc = fraction(da, bS, bU)
539 539      let dd = fraction(da, bT, bU)
540 540      $Tuple2(nil, $Tuple2(nil, [dc, dd]))
541 541      }
542 542  
543 543  
544 544  
545 545  @Callable(aF)
546 546  func init (cK,cL,cM,cN) = {
547 547      let bJ = Address(cK)
548 548      let de = $Tuple2(cM[0], bo(cN[0]))
549 549      let ci = de._1
550 550      let df = de._2
551 551      let dg = $Tuple2(cM[1], bo(cN[1]))
552 552      let cj = dg._1
553 553      let dh = dg._2
554 554      if (!(containsElement([X, Y, Z, aa], aF.originCallerPublicKey)))
555 555          then throw("Only admin can call this function")
556 556          else if ((size(cL) != 1))
557 557              then throw("Wrong args size")
558 558              else if (isDefined(getBoolean(bJ, c)))
559 559                  then throw("DApp is already active")
560 560                  else if ((df == dh))
561 561                      then throw("Assets must be different")
562 562                      else {
563 563                          let di = aG(df)
564 564                          let bW = di._1
565 565                          let bX = di._2
566 566                          let bY = di._3
567 567                          let dj = aG(dh)
568 568                          let ca = dj._1
569 569                          let cb = dj._2
570 570                          let cc = dj._3
571 571                          let dk = (cL[0] == "true")
572 572                          let dl = ((("s" + take(bX, 7)) + "_") + take(cb, 7))
573 573                          let dm = ((((("ShareToken of SwopFi protocol for " + bX) + " and ") + cb) + " at address ") + toString(this))
574 574                          let co = ((bY + cc) / 2)
575 575                          let dn = pow(ci, bY, 5, 1, bY, DOWN)
576 576                          let do = pow(cj, cc, 5, 1, cc, DOWN)
577 577                          let dp = pow(10, 0, co, 0, 0, DOWN)
578 578                          let dq = fraction(dn, do, dp)
579 579                          let dr = Issue(dl, dm, dq, co, true)
580 580                          let ds = calculateAssetId(dr)
581 581                          let dt = if (contains(aj, bW))
582 582                              then invoke(aF.caller, "stakeUnstake", [true, ci, bW], nil)
583 583                              else 0
584 584                          if ((dt == dt))
585 585                              then {
586 586                                  let du = if (contains(aj, ca))
587 587                                      then invoke(aF.caller, "stakeUnstake", [true, cj, ca], nil)
588 588                                      else 0
589 589                                  if ((du == du))
590 590                                      then {
591 591                                          let dv = [StringEntry(b, a), BooleanEntry(c, true), StringEntry(e, bW), StringEntry(f, ca), IntegerEntry(g, ci), IntegerEntry(h, cj), IntegerEntry(m, getIntegerValue(R, "base_fee_cpmm")), dr, StringEntry(k, toBase58String(ds)), IntegerEntry(l, dq), ScriptTransfer(bJ, dq, ds)]
592 592                                          if (dk)
593 593                                              then $Tuple2(nil, $Tuple2((dv ++ [BooleanEntry(o, dk), IntegerEntry(p, (ao + (aq * ap)))]), nil))
594 594                                              else $Tuple2(nil, $Tuple2(dv, nil))
595 595                                          }
596 596                                      else throw("Strict value is not equal to itself.")
597 597                                  }
598 598                              else throw("Strict value is not equal to itself.")
599 599                          }
600 600      }
601 601  
602 602  
603 603  
604 604  @Callable(aF)
605 605  func initWithInitRatio (cK,cL,cM,cN) = {
606 606      let bJ = Address(cK)
607 607      let dw = $Tuple5(parseIntValue(cL[0]), parseIntValue(cL[1]), cL[2], cL[3], (cL[4] == "true"))
608 608      let dx = dw._1
609 609      let dy = dw._2
610 610      let dz = dw._3
611 611      let dA = dw._4
612 612      let dk = dw._5
613 613      if (!(containsElement([X, Y, Z, aa], aF.originCallerPublicKey)))
614 614          then throw("Only admin can call this function")
615 615          else if ((size(cL) != 5))
616 616              then throw("Wrong args size")
617 617              else if (isDefined(getBoolean(bJ, c)))
618 618                  then throw("DApp is already active")
619 619                  else if ((dz == dA))
620 620                      then throw("Assets must be different")
621 621                      else {
622 622                          let dB = aG(dz)
623 623                          let bW = dB._1
624 624                          let bX = dB._2
625 625                          let bY = dB._3
626 626                          let dC = aG(dA)
627 627                          let ca = dC._1
628 628                          let cb = dC._2
629 629                          let cc = dC._3
630 630                          let dl = ((("s" + take(bX, 7)) + "_") + take(cb, 7))
631 631                          let dm = ((((("ShareToken of SwopFi protocol for " + bX) + " and ") + cb) + " at address ") + toString(this))
632 632                          let co = ((bY + cc) / 2)
633 633                          let dq = 0
634 634                          let dr = Issue(dl, dm, dq, co, true)
635 635                          let ds = calculateAssetId(dr)
636 636                          let dv = [StringEntry(b, a), BooleanEntry(c, true), StringEntry(e, bW), StringEntry(f, ca), IntegerEntry(i, dx), IntegerEntry(j, dy), IntegerEntry(g, 0), IntegerEntry(h, 0), IntegerEntry(m, getIntegerValue(R, "base_fee_cpmm")), dr, StringEntry(k, toBase58String(ds)), IntegerEntry(l, dq)]
637 637                          if (dk)
638 638                              then $Tuple2(nil, $Tuple2((dv ++ [BooleanEntry(o, dk), IntegerEntry(p, (ao + (aq * ap)))]), nil))
639 639                              else $Tuple2(nil, $Tuple2(dv, nil))
640 640                          }
641 641      }
642 642  
643 643  
644 644  
645 645  @Callable(aF)
646 646  func keepLimitForFirstHarvest (cK,cL,cM,cN) = valueOrElse(bx(toString(aF.caller)), valueOrElse(bw(), if (!(containsElement([X, Y, Z, aa], aF.originCallerPublicKey)))
647 647      then throw("Only admin can call this function")
648 648      else if ((size(cL) != 1))
649 649          then throw("Wrong args size")
650 650          else {
651 651              let dD = parseIntValue(cL[0])
652 652              $Tuple2(nil, $Tuple2([IntegerEntry(q, dD)], nil))
653 653              }))
654 654  
655 655  
656 656  
657 657  @Callable(aF)
658 658  func exchange (cK,cL,cM,cN) = valueOrElse(bx(toString(aF.caller)), valueOrElse(bz(toString(aF.caller)), valueOrElse(bw(), {
659 659      let bJ = Address(cK)
660 660      let dE = $Tuple2(cM[0], bo(cN[0]))
661 661      let aV = dE._1
662 662      let cq = dE._2
663 663      let aW = parseIntValue(cL[0])
664 664      let dF = bE(aF.caller)
665 665      let bF = dF._1
666 666      let bG = dF._2
667 667      let bu = dF._3
668 668      let bv = dF._4
669 669      let dG = bA(aF.caller, bu, bv)
670 670      let bs = dG._1
671 671      let bt = dG._2
672 672      let bq = dG._3
673 673      let br = dG._4
674 674      if ((size(cL) != 1))
675 675          then throw("Wrong args size")
676 676          else if (if ((bs == 0))
677 677              then true
678 678              else (bt == 0))
679 679              then throw("Can't exchange with zero balance")
680 680              else if ((0 >= aW))
681 681                  then throw(("Minimal amount to receive must be positive. Actual: " + toString(aW)))
682 682                  else if ((size(cM) != 1))
683 683                      then throw("One attached payment expected")
684 684                      else if (!(containsElement([bu, bv], cq)))
685 685                          then throw(((("Incorrect asset attached. Expected: " + bF) + " or ") + bG))
686 686                          else if (if ((bs > bq))
687 687                              then true
688 688                              else (bt > br))
689 689                              then $Tuple2(nil, ([ScriptTransfer(bJ, aV, cq)] ++ bp(bq, br, bs, bt, bF, bG)))
690 690                              else {
691 691                                  let dH = bI(aF.caller, aF.originCaller)
692 692                                  let aZ = dH._1
693 693                                  let bL = dH._2
694 694                                  let bM = dH._3
695 695                                  let dI = if ((cq == bu))
696 696                                      then aU(aV, aW, bs, bt, aZ, bL, bM)
697 697                                      else aU(aV, aW, bt, bs, aZ, bL, bM)
698 698                                  let bc = dI._1
699 699                                  let bd = dI._2
700 700                                  let be = dI._3
701 701                                  let bf = dI._4
702 702                                  let dJ = if ((cq == bu))
703 703                                      then $Tuple3((bs + aV), (((bt - bd) - be) - bf), bv)
704 704                                      else $Tuple3((((bs - bd) - be) - bf), (bt + aV), bu)
705 705                                  let cz = dJ._1
706 706                                  let cA = dJ._2
707 707                                  let dK = dJ._3
708 708                                  let dL = if ((cq == bu))
709 709                                      then $Tuple2(aV, ((bd + be) + bf))
710 710                                      else $Tuple2(((bd + be) + bf), aV)
711 711                                  let dM = dL._1
712 712                                  let dN = dL._2
713 713                                  let dt = if (contains(aj, bF))
714 714                                      then invoke(aF.caller, "stakeUnstake", [(cq == bu), dM, bF], nil)
715 715                                      else 0
716 716                                  if ((dt == dt))
717 717                                      then {
718 718                                          let du = if (contains(aj, bG))
719 719                                              then invoke(aF.caller, "stakeUnstake", [(cq == bv), dN, bG], nil)
720 720                                              else 0
721 721                                          if ((du == du))
722 722                                              then $Tuple2(nil, $Tuple2([IntegerEntry(g, cz), IntegerEntry(h, cA), ScriptTransfer(bJ, bd, dK), ScriptTransfer(ab, be, dK), ScriptTransfer(ac, bf, dK)], [bd, dK]))
723 723                                              else throw("Strict value is not equal to itself.")
724 724                                          }
725 725                                      else throw("Strict value is not equal to itself.")
726 726                                  }
727 727      })))
728 728  
729 729  
730 730  
731 731  @Callable(aF)
732 732  func replenishWithTwoTokens (cK,cL,cM,cN) = valueOrElse(bx(toString(aF.caller)), valueOrElse(bz(toString(aF.caller)), valueOrElse(bw(), {
733 733      let bJ = Address(cK)
734 734      let df = bo(cN[0])
735 735      let dh = bo(cN[1])
736 736      let dO = (cL[0] == "true")
737 737      let dP = parseIntValue(cL[1])
738 738      let dQ = bE(aF.caller)
739 739      let bF = dQ._1
740 740      let bG = dQ._2
741 741      let bu = dQ._3
742 742      let bv = dQ._4
743 743      let bH = dQ._5
744 744      let dR = bA(aF.caller, bu, bv)
745 745      let bs = dR._1
746 746      let bt = dR._2
747 747      let bq = dR._3
748 748      let br = dR._4
749 749      let bU = bD(aF.caller)
750 750      if ((size(cL) != 2))
751 751          then throw("Wrong args size")
752 752          else if (if ((size(cM) != 2))
753 753              then (size(cM) != 3)
754 754              else false)
755 755              then throw("Two or three payments expected")
756 756              else if (if ((df != bu))
757 757                  then true
758 758                  else (dh != bv))
759 759                  then throw(((("Incorrect assets attached. Expected: " + bF) + " and ") + bG))
760 760                  else if (if ((bs > bq))
761 761                      then true
762 762                      else (bt > br))
763 763                      then $Tuple2(nil, ([ScriptTransfer(bJ, cM[0], df), ScriptTransfer(bJ, cM[1], dh)] ++ (if ((size(cM) == 3))
764 764                          then [AttachedPayment(if ((cN[2] == base58''))
765 765                              then unit
766 766                              else cN[2], cM[2])]
767 767                          else (nil ++ bp(bq, br, bs, bt, bF, bG)))))
768 768                      else {
769 769                          let dS = bN(cM[0], cM[1], df, dh, bs, bt, bU)
770 770                          let cn = dS._1
771 771                          let ck = dS._2
772 772                          let cl = dS._3
773 773                          let ci = dS._4
774 774                          let cj = dS._5
775 775                          if ((cn == 0))
776 776                              then throw("Too small amount to replenish")
777 777                              else if ((0 > ck))
778 778                                  then throw("Change < 0")
779 779                                  else {
780 780                                      let dt = if (contains(aj, bF))
781 781                                          then invoke(aF.caller, "stakeUnstake", [true, ci, bF], nil)
782 782                                          else 0
783 783                                      if ((dt == dt))
784 784                                          then {
785 785                                              let du = if (contains(aj, bG))
786 786                                                  then invoke(aF.caller, "stakeUnstake", [true, cj, bG], nil)
787 787                                                  else 0
788 788                                              if ((du == du))
789 789                                                  then {
790 790                                                      let dT = if (dO)
791 791                                                          then {
792 792                                                              let dU = ([AttachedPayment(bH, cn)] ++ (if ((size(cM) == 3))
793 793                                                                  then [AttachedPayment(if ((cN[2] == base58''))
794 794                                                                      then unit
795 795                                                                      else cN[2], cM[2])]
796 796                                                                  else nil))
797 797                                                              let dV = invoke(aF.caller, "reissueShareToken", [cn], nil)
798 798                                                              if ((dV == dV))
799 799                                                                  then {
800 800                                                                      let dW = invoke(af, "lockShareTokensFromPool", [cK, toString(aF.caller), dP], dU)
801 801                                                                      if ((dW == dW))
802 802                                                                          then nil
803 803                                                                          else throw("Strict value is not equal to itself.")
804 804                                                                      }
805 805                                                                  else throw("Strict value is not equal to itself.")
806 806                                                              }
807 807                                                          else [Reissue(bH, cn, true), ScriptTransfer(bJ, cn, bH)]
808 808                                                      $Tuple2(nil, $Tuple2(([IntegerEntry(g, (bs + ci)), IntegerEntry(h, (bt + cj)), IntegerEntry(l, (bU + cn)), ScriptTransfer(bJ, ck, cl)] ++ dT), nil))
809 809                                                      }
810 810                                                  else throw("Strict value is not equal to itself.")
811 811                                              }
812 812                                          else throw("Strict value is not equal to itself.")
813 813                                      }
814 814                          }
815 815      })))
816 816  
817 817  
818 818  
819 819  @Callable(aF)
820 820  func replenishWithOneToken (cK,cL,cM,cN) = valueOrElse(bx(toString(aF.caller)), valueOrElse(bz(toString(aF.caller)), valueOrElse(bw(), {
821 821      let bJ = Address(cK)
822 822      let cq = bo(cN[0])
823 823      let aV = cM[0]
824 824      let ct = parseIntValue(cL[0])
825 825      let dO = (cL[1] == "true")
826 826      let dP = parseIntValue(cL[2])
827 827      let dX = bE(aF.caller)
828 828      let bF = dX._1
829 829      let bG = dX._2
830 830      let bu = dX._3
831 831      let bv = dX._4
832 832      let bH = dX._5
833 833      let dY = bA(aF.caller, bu, bv)
834 834      let bs = dY._1
835 835      let bt = dY._2
836 836      let bq = dY._3
837 837      let br = dY._4
838 838      let bU = bD(aF.caller)
839 839      let cd = ((bs + bt) == 0)
840 840      if ((size(cL) != 3))
841 841          then throw("Wrong args size")
842 842          else if (if ((size(cM) != 1))
843 843              then (size(cM) != 2)
844 844              else false)
845 845              then throw("Two or one attached assets expected")
846 846              else if (if ((cq != bu))
847 847                  then (cq != bv)
848 848                  else false)
849 849                  then throw(((("Incorrect asset attached. Expected: " + bF) + " or ") + bG))
850 850                  else if (cd)
851 851                      then throw("For initial exchanger you need to use two tokens")
852 852                      else if (if ((bs > bq))
853 853                          then true
854 854                          else (bt > br))
855 855                          then $Tuple2(nil, ([ScriptTransfer(bJ, aV, cq)] ++ (if ((size(cM) == 2))
856 856                              then [AttachedPayment(if ((cN[2] == base58''))
857 857                                  then unit
858 858                                  else cN[2], cM[2])]
859 859                              else (nil ++ bp(bq, br, bs, bt, bF, bG)))))
860 860                          else {
861 861                              let dZ = bI(aF.caller, aF.originCaller)
862 862                              let aZ = dZ._1
863 863                              let bL = dZ._2
864 864                              let bM = dZ._3
865 865                              let ea = aG(cq)
866 866                              let eb = ea._1
867 867                              let ec = ea._2
868 868                              let ed = cp(aV, cq, bu, bv, bs, bt, bU, aZ, bL, bM, ct)
869 869                              let cn = ed._1
870 870                              let cz = ed._2
871 871                              let cA = ed._3
872 872                              let ee = ed._4
873 873                              let bf = ed._5
874 874                              let ef = ed._6
875 875                              let eg = if ((ef == bu))
876 876                                  then bF
877 877                                  else bG
878 878                              if ((cn == 0))
879 879                                  then throw("Too small amount to replenish")
880 880                                  else {
881 881                                      let dt = if (contains(aj, eb))
882 882                                          then invoke(aF.caller, "stakeUnstake", [true, aV, eb], nil)
883 883                                          else 0
884 884                                      if ((dt == dt))
885 885                                          then {
886 886                                              let du = if (contains(aj, eg))
887 887                                                  then invoke(aF.caller, "stakeUnstake", [false, (ee + bf), eg], nil)
888 888                                                  else 0
889 889                                              if ((du == du))
890 890                                                  then {
891 891                                                      let dT = if (dO)
892 892                                                          then {
893 893                                                              let dU = ([AttachedPayment(bH, cn)] ++ (if ((size(cM) == 2))
894 894                                                                  then [AttachedPayment(if ((cN[1] == base58''))
895 895                                                                      then unit
896 896                                                                      else cN[1], cM[1])]
897 897                                                                  else nil))
898 898                                                              let dV = invoke(aF.caller, "reissueShareToken", [cn], nil)
899 899                                                              if ((dV == dV))
900 900                                                                  then {
901 901                                                                      let dW = invoke(af, "lockShareTokensFromPool", [cK, toString(aF.caller), dP], dU)
902 902                                                                      if ((dW == dW))
903 903                                                                          then nil
904 904                                                                          else throw("Strict value is not equal to itself.")
905 905                                                                      }
906 906                                                                  else throw("Strict value is not equal to itself.")
907 907                                                              }
908 908                                                          else [Reissue(bH, cn, true), ScriptTransfer(bJ, cn, bH)]
909 909                                                      $Tuple2(nil, $Tuple2(([IntegerEntry(g, cz), IntegerEntry(h, cA), IntegerEntry(l, (bU + cn)), ScriptTransfer(ab, ee, ef), ScriptTransfer(ac, bf, ef)] ++ dT), nil))
910 910                                                      }
911 911                                                  else throw("Strict value is not equal to itself.")
912 912                                              }
913 913                                          else throw("Strict value is not equal to itself.")
914 914                                      }
915 915                              }
916 916      })))
917 917  
918 918  
919 919  
920 920  @Callable(aF)
921 921  func withdraw (cK,cL,cM,cN) = valueOrElse(bx(toString(aF.caller)), valueOrElse(bw(), {
922 922      let bJ = Address(cK)
923 923      let eh = bE(aF.caller)
924 924      let bF = eh._1
925 925      let bG = eh._2
926 926      let bu = eh._3
927 927      let bv = eh._4
928 928      let bH = eh._5
929 929      let ei = bA(aF.caller, bu, bv)
930 930      let bs = ei._1
931 931      let bt = ei._2
932 932      let bq = ei._3
933 933      let br = ei._4
934 934      let bU = bD(aF.caller)
935 935      let ej = if ((size(cM) == 1))
936 936          then {
937 937              let ek = bo(cN[0])
938 938              if ((ek != bH))
939 939                  then throw(("Incorrect asset attached. Expected: " + toBase58String(bH)))
940 940                  else $Tuple2(cM[0], ek)
941 941              }
942 942          else $Tuple2(0, bH)
943 943      let aV = ej._1
944 944      let cq = ej._2
945 945      if ((size(cL) != 1))
946 946          then throw("Wrong args size")
947 947          else if ((size(cM) > 1))
948 948              then throw("One attached payment expected")
949 949              else if (if ((bs > bq))
950 950                  then true
951 951                  else (bt > br))
952 952                  then $Tuple2(nil, ([ScriptTransfer(bJ, aV, cq)] ++ bp(bq, br, bs, bt, bF, bG)))
953 953                  else {
954 954                      let el = parseIntValue(valueOrElse(cL[0], "0"))
955 955                      let em = if ((el > 0))
956 956                          then invoke(af, "withdrawShareTokensFromPool", [cK, toString(aF.caller), el], nil)
957 957                          else 0
958 958                      if ((em == em))
959 959                          then {
960 960                              let da = (aV + el)
961 961                              let dc = fraction(da, bs, bU)
962 962                              let dd = fraction(da, bt, bU)
963 963                              let dt = if (contains(aj, bF))
964 964                                  then invoke(aF.caller, "stakeUnstake", [false, dc, bF], nil)
965 965                                  else 0
966 966                              if ((dt == dt))
967 967                                  then {
968 968                                      let du = if (contains(aj, bG))
969 969                                          then invoke(aF.caller, "stakeUnstake", [false, dd, bG], nil)
970 970                                          else 0
971 971                                      if ((du == du))
972 972                                          then $Tuple2([ScriptTransfer(aF.caller, el, bH)], $Tuple2([IntegerEntry(g, (bs - dc)), IntegerEntry(h, (bt - dd)), IntegerEntry(l, (bU - da)), Burn(bH, da), ScriptTransfer(bJ, dc, bu), ScriptTransfer(bJ, dd, bv)], nil))
973 973                                          else throw("Strict value is not equal to itself.")
974 974                                      }
975 975                                  else throw("Strict value is not equal to itself.")
976 976                              }
977 977                          else throw("Strict value is not equal to itself.")
978 978                      }
979 979      }))
980 980  
981 981  
982 982  
983 983  @Callable(aF)
984 984  func withdrawOneToken (cK,cL,cM,cN) = valueOrElse(bx(toString(aF.caller)), valueOrElse(bz(toString(aF.caller)), valueOrElse(bw(), {
985 985      let bJ = Address(cK)
986 986      let en = if ((cL[0] == ""))
987 987          then unit
988 988          else fromBase58String(cL[0])
989 989      let eo = bE(aF.caller)
990 990      let bF = eo._1
991 991      let bG = eo._2
992 992      let bu = eo._3
993 993      let bv = eo._4
994 994      let bH = eo._5
995 995      let ep = bA(aF.caller, bu, bv)
996 996      let bs = ep._1
997 997      let bt = ep._2
998 998      let bq = ep._3
999 999      let br = ep._4
1000 1000      let bU = bD(aF.caller)
1001 1001      let eq = if ((size(cM) == 1))
1002 1002          then {
1003 1003              let ek = bo(cN[0])
1004 1004              if ((ek != bH))
1005 1005                  then throw(("Incorrect asset attached. Expected: " + toBase58String(bH)))
1006 1006                  else $Tuple2(cM[0], ek)
1007 1007              }
1008 1008          else $Tuple2(0, bH)
1009 1009      let aV = eq._1
1010 1010      let cq = eq._2
1011 1011      let er = parseIntValue(cL[1])
1012 1012      if ((size(cL) != 3))
1013 1013          then throw("Wrong args size")
1014 1014          else if ((size(cM) > 1))
1015 1015              then throw("One attached payment expected")
1016 1016              else if ((cq != bH))
1017 1017                  then throw(("Incorrect asset attached. Expected: " + toBase58String(bH)))
1018 1018                  else if (!(containsElement([bu, bv], en)))
1019 1019                      then throw("Incorrect withdraw asset.")
1020 1020                      else if (if ((bs > bq))
1021 1021                          then true
1022 1022                          else (bt > br))
1023 1023                          then $Tuple2(nil, ([ScriptTransfer(bJ, aV, cq)] ++ bp(bq, br, bs, bt, bF, bG)))
1024 1024                          else {
1025 1025                              let el = parseIntValue(valueOrElse(cL[2], "0"))
1026 1026                              let em = if ((el > 0))
1027 1027                                  then invoke(af, "withdrawShareTokensFromPool", [cK, toString(aF.caller), el], nil)
1028 1028                                  else 0
1029 1029                              if ((em == em))
1030 1030                                  then {
1031 1031                                      let da = (aV + el)
1032 1032                                      let dc = fraction(da, bs, bU)
1033 1033                                      let dd = fraction(da, bt, bU)
1034 1034                                      let es = bI(aF.caller, aF.originCaller)
1035 1035                                      let aZ = es._1
1036 1036                                      let bL = es._2
1037 1037                                      let bM = es._3
1038 1038                                      let et = if ((en == bu))
1039 1039                                          then aU(dd, er, (bt - dd), (bs - dc), aZ, bL, bM)
1040 1040                                          else aU(dc, er, (bs - dc), (bt - dd), aZ, bL, bM)
1041 1041                                      let bc = et._1
1042 1042                                      let bd = et._2
1043 1043                                      let be = et._3
1044 1044                                      let bf = et._4
1045 1045                                      let eu = if ((en == bu))
1046 1046                                          then {
1047 1047                                              let ev = if (contains(aj, bF))
1048 1048                                                  then invoke(aF.caller, "stakeUnstake", [false, (((dc + bd) + be) + bf), bF], nil)
1049 1049                                                  else 0
1050 1050                                              if ((ev == ev))
1051 1051                                                  then $Tuple4(((((bs - dc) - bd) - be) - bf), bt, bu, [ScriptTransfer(bJ, (dc + bd), bu)])
1052 1052                                                  else throw("Strict value is not equal to itself.")
1053 1053                                              }
1054 1054                                          else {
1055 1055                                              let ev = if (contains(aj, bG))
1056 1056                                                  then invoke(aF.caller, "stakeUnstake", [false, (((dd + bd) + be) + bf), bG], nil)
1057 1057                                                  else 0
1058 1058                                              if ((ev == ev))
1059 1059                                                  then $Tuple4(bs, ((((bt - dd) - bd) - be) - bf), bv, [ScriptTransfer(bJ, (dd + bd), bv)])
1060 1060                                                  else throw("Strict value is not equal to itself.")
1061 1061                                              }
1062 1062                                      let cz = eu._1
1063 1063                                      let cA = eu._2
1064 1064                                      let ew = eu._3
1065 1065                                      let ex = eu._4
1066 1066                                      $Tuple2([ScriptTransfer(aF.caller, el, bH)], $Tuple2(([IntegerEntry(g, cz), IntegerEntry(h, cA), IntegerEntry(l, (bU - da)), Burn(bH, da), ScriptTransfer(ab, be, ew), ScriptTransfer(ac, bf, ew)] ++ ex), nil))
1067 1067                                      }
1068 1068                                  else throw("Strict value is not equal to itself.")
1069 1069                              }
1070 1070      })))
1071 1071  
1072 1072  
1073 1073  
1074 1074  @Callable(aF)
1075 1075  func takeIntoAccountExtraFunds (cK,cL,cM,cN) = valueOrElse(bx(toString(aF.caller)), valueOrElse(bw(), {
1076 1076      let ey = bE(aF.caller)
1077 1077      let bF = ey._1
1078 1078      let bG = ey._2
1079 1079      let bu = ey._3
1080 1080      let bv = ey._4
1081 1081      let ez = if (if ((bu == ag))
1082 1082          then true
1083 1083          else (bv == ag))
1084 1084          then invoke(aF.caller, "claimNetrinoRewards", nil, nil)
1085 1085          else nil
1086 1086      if ((ez == ez))
1087 1087          then {
1088 1088              let eA = bA(aF.caller, bu, bv)
1089 1089              let bs = eA._1
1090 1090              let bt = eA._2
1091 1091              let bq = eA._3
1092 1092              let br = eA._4
1093 1093              let bB = eA._5
1094 1094              let bC = eA._6
1095 1095              let eB = (bq - bs)
1096 1096              let eC = (br - bt)
1097 1097              let eD = if ((bu == ai))
1098 1098                  then $Tuple2((bq - bB), eC)
1099 1099                  else if ((bv == ai))
1100 1100                      then $Tuple2(eB, (br - bC))
1101 1101                      else $Tuple2(eB, eC)
1102 1102              let eE = eD._1
1103 1103              let eF = eD._2
1104 1104              if ((size(cL) != 0))
1105 1105                  then throw("Wrong args size")
1106 1106                  else if ((ab != aF.originCaller))
1107 1107                      then throw("Only the wallet can call this function")
1108 1108                      else if (if ((0 > eB))
1109 1109                          then true
1110 1110                          else (0 > eC))
1111 1111                          then aM("Enroll amount negative")
1112 1112                          else if (if ((eB == 0))
1113 1113                              then (eC == 0)
1114 1114                              else false)
1115 1115                              then throw("No money to take")
1116 1116                              else {
1117 1117                                  let dt = if (if (contains(aj, bF))
1118 1118                                      then (eE > 0)
1119 1119                                      else false)
1120 1120                                      then invoke(aF.caller, "stakeUnstake", [true, eE, bF], nil)
1121 1121                                      else 0
1122 1122                                  if ((dt == dt))
1123 1123                                      then {
1124 1124                                          let du = if (if (contains(aj, bG))
1125 1125                                              then (eF > 0)
1126 1126                                              else false)
1127 1127                                              then invoke(aF.caller, "stakeUnstake", [true, eF, bG], nil)
1128 1128                                              else 0
1129 1129                                          if ((du == du))
1130 1130                                              then $Tuple2(nil, $Tuple2([IntegerEntry(g, (bs + eB)), IntegerEntry(h, (bt + eC))], nil))
1131 1131                                              else throw("Strict value is not equal to itself.")
1132 1132                                          }
1133 1133                                      else throw("Strict value is not equal to itself.")
1134 1134                                  }
1135 1135              }
1136 1136          else throw("Strict value is not equal to itself.")
1137 1137      }))
1138 1138  
1139 1139  
1140 1140  @Verifier(eG)
1141 1141  func eH () = {
1142 1142      let eI = {
1143 1143          let eJ = if (sigVerify(eG.bodyBytes, eG.proofs[0], X))
1144 1144              then 1
1145 1145              else 0
1146 1146          let eK = if (sigVerify(eG.bodyBytes, eG.proofs[1], Y))
1147 1147              then 1
1148 1148              else 0
1149 1149          let eL = if (sigVerify(eG.bodyBytes, eG.proofs[2], Z))
1150 1150              then 1
1151 1151              else 0
1152 1152          (((eJ + eK) + eL) >= 2)
1153 1153          }
1154 1154      eI
1155 1155      }
1156 1156

Old	New		Differences
186	186		else throw(($getType(aE) + " couldn't be cast to (Int, Int, Int, Int, Int)"))
187	187		}
188	188		if ((aD == aD))
189		-	then aD
	189	+	then aD._2
190	190		else throw("Strict value is not equal to itself.")
191	191		}
192	192		else 0

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let a = "1.0.0"
5	5
6	6		let b = "version"
7	7
8	8		let c = "active"
9	9
10	10		let d = "deprecated_"
11	11
12	12		let e = "A_asset_id"
13	13
14	14		let f = "B_asset_id"
15	15
16	16		let g = "A_asset_balance"
17	17
18	18		let h = "B_asset_balance"
19	19
20	20		let i = "A_asset_init"
21	21
22	22		let j = "B_asset_init"
23	23
24	24		let k = "share_asset_id"
25	25
26	26		let l = "share_asset_supply"
27	27
28	28		let m = "commission"
29	29
30	30		let n = "shutdown_cause"
31	31
32	32		let o = "first_harvest"
33	33
34	34		let p = "first_harvest_height"
35	35
36	36		let q = "share_limit_on_first_harvest"
37	37
38	38		let r = "base_period"
39	39
40	40		let s = "period_length"
41	41
42	42		let t = "start_height"
43	43
44	44		let u = "staking_usdnnsbt_address"
45	45
46	46		let v = "staking_eurn_address"
47	47
48	48		let w = "leasing_amount"
49	49
50	50		let x = "usdn_asset_id"
51	51
52	52		let y = "eurn_asset_id"
53	53
54	54		let z = "l2mp_asset_id"
55	55
56	56		let A = "staking_assets"
57	57
58	58		let B = "active_all_contracts"
59	59
60	60		let C = "discounts"
61	61
62	62		let D = "discount_values"
63	63
64	64		let E = "_GSwop_amount"
65	65
66	66		let F = "_SWOP_amount"
67	67
68	68		let G = "pool_"
69	69
70	70		let H = "admin_pub_1"
71	71
72	72		let I = "admin_pub_2"
73	73
74	74		let J = "admin_pub_3"
75	75
76	76		let K = "admin_invoke_pub"
77	77
78	78		let L = "money_box_address"
79	79
80	80		let M = "team_box_address"
81	81
82	82		let N = "voting_address"
83	83
84	84		let O = "governance_address"
85	85
86	86		let P = "farming_address"
87	87
88	88		let Q = "staking_l2mp_address"
89	89
90	90		let R = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
91	91
92	92		func S (T) = {
93	93		let U = getString(R, T)
94	94		if ($isInstanceOf(U, "String"))
95	95		then {
96	96		let V = U
97	97		fromBase58String(V)
98	98		}
99	99		else {
100	100		let W = U
101	101		throw((T + "is empty"))
102	102		}
103	103		}
104	104
105	105
106	106		let X = S(H)
107	107
108	108		let Y = S(I)
109	109
110	110		let Z = S(J)
111	111
112	112		let aa = S(K)
113	113
114	114		let ab = Address(S(L))
115	115
116	116		let ac = Address(S(M))
117	117
118	118		let ad = Address(S(N))
119	119
120	120		let ae = Address(S(O))
121	121
122	122		let af = Address(S(P))
123	123
124	124		let ag = S(x)
125	125
126	126		let ah = S(y)
127	127
128	128		let ai = S(z)
129	129
130	130		let aj = getStringValue(R, A)
131	131
132	132		let ak = Address(S(u))
133	133
134	134		let al = Address(S(v))
135	135
136	136		let am = Address(S(Q))
137	137
138	138		let an = valueOrErrorMessage(getInteger(ad, r), "Empty kBasePeriod")
139	139
140	140		let ao = valueOrErrorMessage(getInteger(ad, t), "Empty kStartHeight")
141	141
142	142		let ap = valueOrErrorMessage(getInteger(ad, s), "Empty kPeriodLength")
143	143
144	144		let aq = ((an + ((height - ao) / ap)) + 3)
145	145
146	146		let ar = getBooleanValue(R, B)
147	147
148	148		let as = 1000000
149	149
150	150		let at = 100000000
151	151
152	152		let au = toBigInt(10000000000000000)
153	153
154	154		func av (aw,ax) = {
155	155		let U = aw
156	156		if ($isInstanceOf(U, "ByteVector"))
157	157		then {
158	158		let ay = U
159	159		assetBalance(ax, ay)
160	160		}
161	161		else if ($isInstanceOf(U, "Unit"))
162	162		then {
163	163		let az = U
164	164		wavesBalance(ax).available
165	165		}
166	166		else throw("Match error")
167	167		}
168	168
169	169
170	170		func aA (aw,ax) = {
171	171		let aB = {
172	172		let U = aw
173	173		if ($isInstanceOf(U, "ByteVector"))
174	174		then {
175	175		let aC = U
176	176		if ((aC == ag))
177	177		then getInteger(ak, ((("rpd_balance_" + toBase58String(aC)) + "_") + toString(ax)))
178	178		else if ((aC == ah))
179	179		then getInteger(al, ((("%s%s%s__stakingBalance__" + toBase58String(aC)) + "__") + toString(ax)))
180	180		else if ((aC == ai))
181	181		then {
182	182		let aD = {
183	183		let aE = invoke(am, "getUserAssetsREADONLY", [ax], nil)
184	184		if ($isInstanceOf(aE, "(Int, Int, Int, Int, Int)"))
185	185		then aE
186	186		else throw(($getType(aE) + " couldn't be cast to (Int, Int, Int, Int, Int)"))
187	187		}
188	188		if ((aD == aD))
189		-	then aD
	189	+	then aD._2
190	190		else throw("Strict value is not equal to itself.")
191	191		}
192	192		else 0
193	193		}
194	194		else if ($isInstanceOf(U, "Unit"))
195	195		then valueOrElse(getInteger(ax, w), 0)
196	196		else throw("Match error")
197	197		}
198	198		let U = aB
199	199		if ($isInstanceOf(U, "Int"))
200	200		then {
201	201		let aF = U
202	202		aF
203	203		}
204	204		else 0
205	205		}
206	206
207	207
208	208		func aG (aw) = {
209	209		let U = aw
210	210		if (if ($isInstanceOf(U, "String"))
211	211		then true
212	212		else $isInstanceOf(U, "ByteVector"))
213	213		then {
214	214		let ay = U
215	215		let aH = {
216	216		let aI = ay
217	217		if ($isInstanceOf(aI, "ByteVector"))
218	218		then {
219	219		let aC = aI
220	220		$Tuple2(toBase58String(aC), aC)
221	221		}
222	222		else if ($isInstanceOf(aI, "String"))
223	223		then {
224	224		let aC = aI
225	225		$Tuple2(aC, fromBase58String(aC))
226	226		}
227	227		else throw("Match error")
228	228		}
229	229		let aJ = aH._1
230	230		let aK = aH._2
231	231		let aL = valueOrErrorMessage(assetInfo(aK), (("Asset " + aJ) + " doesn't exist"))
232	232		$Tuple3(aJ, aL.name, aL.decimals)
233	233		}
234	234		else if ($isInstanceOf(U, "Unit"))
235	235		then {
236	236		let az = U
237	237		$Tuple3("WAVES", "WAVES", 8)
238	238		}
239	239		else throw("Match error")
240	240		}
241	241
242	242
243	243		func aM (aN) = [BooleanEntry(c, false), StringEntry(n, aN)]
244	244
245	245
246	246		func aO (aP) = {
247	247		let aQ = valueOrElse(getInteger(ae, (toString(aP) + F)), 0)
248	248		let aR = valueOrElse(getInteger(ae, (toString(aP) + E)), aQ)
249	249		let aS = split(getStringValue(R, D), ",")
250	250		let aT = split(getStringValue(R, C), ",")
251	251		if (if ((aR >= parseIntValue(aS[0])))
252	252		then (parseIntValue(aS[1]) > aR)
253	253		else false)
254	254		then (as - parseIntValue(aT[0]))
255	255		else if (if ((aR >= parseIntValue(aS[1])))
256	256		then (parseIntValue(aS[2]) > aR)
257	257		else false)
258	258		then (as - parseIntValue(aT[1]))
259	259		else if (if ((aR >= parseIntValue(aS[2])))
260	260		then (parseIntValue(aS[3]) > aR)
261	261		else false)
262	262		then (as - parseIntValue(aT[2]))
263	263		else if (if ((aR >= parseIntValue(aS[3])))
264	264		then (parseIntValue(aS[4]) > aR)
265	265		else false)
266	266		then (as - parseIntValue(aT[3]))
267	267		else if ((aR >= parseIntValue(aS[4])))
268	268		then (as - parseIntValue(aT[4]))
269	269		else as
270	270		}
271	271
272	272
273	273		func aU (aV,aW,aX,aY,aZ,ba,bb) = {
274	274		let bc = fraction(aY, aV, (aV + aX))
275	275		let bd = fraction(bc, (as - aZ), as)
276	276		let be = fraction(bc, ba, as)
277	277		let bf = fraction(bc, bb, as)
278	278		if ((aW > bd))
279	279		then throw(((("Calculated amount to receive " + toString(bd)) + " is less than specified minimum ") + toString(aW)))
280	280		else $Tuple4(bc, bd, be, bf)
281	281		}
282	282
283	283
284	284		func bg (aV,bh,aZ) = {
285	285		let bi = (as - aZ)
286	286		let bj = fraction(aZ, 55, 100)
287	287		let bk = (at + fraction((bi * bj), at, (as * as)))
288	288		let bl = ((((bh + fraction(bh, bi, as)) + fraction(aV, bi, as)) - aV) - fraction(aV, (bi * bj), (as * as)))
289	289		let bm = (-(toBigInt(bh)) * toBigInt(aV))
290	290		let bn = ((toBigInt(bl) * toBigInt(bl)) - fraction((toBigInt(4) * bm), toBigInt(bk), toBigInt(at)))
291	291		toInt(fraction((-(toBigInt(bl)) + sqrtBigInt(bn, 0, 0, DOWN)), toBigInt(at), toBigInt((2 * bk))))
292	292		}
293	293
294	294
295	295		func bo (aw) = if ((aw == base58''))
296	296		then unit
297	297		else aw
298	298
299	299
300	300		func bp (bq,br,bs,bt,bu,bv) = aM(((((((((((((((("Suspicious state. Actual balances: " + toString(bq)) + " ") + bu) + ", ") + toString(br)) + " ") + bv) + ". State: ") + toString(bs)) + " ") + bu) + ", ") + toString(bt)) + " ") + bv))
301	301
302	302
303	303		func bw () = if (ar)
304	304		then unit
305	305		else throw("DApp is inactive at this moment")
306	306
307	307
308	308		func bx (by) = if (isDefined(getString(R, (G + by))))
309	309		then unit
310	310		else throw("DApp is not registered pool")
311	311
312	312
313	313		func bz (by) = if (!(valueOrElse(getBoolean(R, (d + by)), false)))
314	314		then unit
315	315		else throw("Pool is deprecated. Only withdraw action allowed.")
316	316
317	317
318	318		func bA (ax,bu,bv) = {
319	319		let bs = getIntegerValue(ax, g)
320	320		let bt = getIntegerValue(ax, h)
321	321		let bB = aA(bu, ax)
322	322		let bC = aA(bv, ax)
323	323		let bq = (av(bu, ax) + bB)
324	324		let br = (av(bv, ax) + bC)
325	325		$Tuple6(bs, bt, bq, br, bB, bC)
326	326		}
327	327
328	328
329	329		func bD (ax) = getIntegerValue(ax, l)
330	330
331	331
332	332		func bE (ax) = {
333	333		let bF = getStringValue(ax, e)
334	334		let bG = getStringValue(ax, f)
335	335		let bu = if ((bF == "WAVES"))
336	336		then unit
337	337		else fromBase58String(bF)
338	338		let bv = if ((bG == "WAVES"))
339	339		then unit
340	340		else fromBase58String(bG)
341	341		let bH = fromBase58String(getStringValue(ax, k))
342	342		$Tuple5(bF, bG, bu, bv, bH)
343	343		}
344	344
345	345
346	346		func bI (ax,bJ) = {
347	347		let bK = aO(bJ)
348	348		let aZ = fraction(getIntegerValue(ax, m), bK, as, CEILING)
349	349		let bL = fraction(aZ, 35, 100)
350	350		let bM = fraction(aZ, 10, 100)
351	351		$Tuple3(aZ, bL, bM)
352	352		}
353	353
354	354
355	355		func bN (bO,bP,bQ,bR,bS,bT,bU) = {
356	356		let bV = aG(bQ)
357	357		let bW = bV._1
358	358		let bX = bV._2
359	359		let bY = bV._3
360	360		let bZ = aG(bR)
361	361		let ca = bZ._1
362	362		let cb = bZ._2
363	363		let cc = bZ._3
364	364		let cd = ((bS + bT) == 0)
365	365		let ce = if (cd)
366	366		then $Tuple5(bO, bP, 0, bQ, toBigInt(1))
367	367		else {
368	368		let cf = fraction(au, toBigInt(bO), toBigInt(bS))
369	369		let cg = fraction(au, toBigInt(bP), toBigInt(bT))
370	370		if ((cg > cf))
371	371		then {
372	372		let ch = fraction(bO, bT, bS)
373	373		$Tuple5(bO, ch, (bP - ch), bR, cf)
374	374		}
375	375		else {
376	376		let ch = fraction(bP, bS, bT)
377	377		$Tuple5(ch, bP, (bO - ch), bQ, cg)
378	378		}
379	379		}
380	380		let ci = ce._1
381	381		let cj = ce._2
382	382		let ck = ce._3
383	383		let cl = ce._4
384	384		let cm = ce._5
385	385		let cn = if (cd)
386	386		then {
387	387		let co = ((bY + cc) / 2)
388	388		fraction(pow(ci, bY, 5, 1, bY, DOWN), pow(cj, cc, 5, 1, cc, DOWN), pow(10, 0, co, 0, 0, DOWN))
389	389		}
390	390		else toInt(fraction(cm, toBigInt(bU), au))
391	391		$Tuple5(cn, ck, cl, ci, cj)
392	392		}
393	393
394	394
395	395		func cp (aV,cq,aC,cr,bS,bT,cs,aZ,bL,bM,ct) = if ((cq == aC))
396	396		then {
397	397		let cu = bg(aV, bS, aZ)
398	398		let cv = aU(cu, ct, bS, bT, aZ, bL, bM)
399	399		let bc = cv._1
400	400		let bd = cv._2
401	401		let be = cv._3
402	402		let cw = cv._4
403	403		let cx = (bS + cu)
404	404		let cy = (((bT + bc) - be) - cw)
405	405		let cz = (bS + aV)
406	406		let cA = ((bT - be) - cw)
407	407		let cf = fraction(toBigInt((aV - cu)), au, toBigInt(cx))
408	408		let cg = fraction(toBigInt(bd), au, toBigInt(cy))
409	409		let cn = toInt(fraction(min([cf, cg]), toBigInt(cs), au))
410	410		let cB = toInt(fraction(fraction(toBigInt((aV - cu)), au, toBigInt(bS)), toBigInt(cs), au))
411	411		let cC = fraction((cn - cB), at, cB)
412	412		$Tuple7(cn, cz, cA, be, cw, cr, cC)
413	413		}
414	414		else {
415	415		let cu = bg(aV, bT, aZ)
416	416		let cD = aU(cu, ct, bT, bS, aZ, bL, bM)
417	417		let bc = cD._1
418	418		let bd = cD._2
419	419		let be = cD._3
420	420		let cw = cD._4
421	421		let cx = (((bS + bc) - be) - cw)
422	422		let cy = (bT + cu)
423	423		let cz = ((bS - be) - cw)
424	424		let cA = (bT + aV)
425	425		let cf = fraction(toBigInt(bd), au, toBigInt(cx))
426	426		let cg = fraction(toBigInt((aV - cu)), au, toBigInt(cy))
427	427		let cn = toInt(fraction(min([cf, cg]), toBigInt(cs), au))
428	428		let cB = toInt(fraction(fraction(toBigInt((aV - cu)), au, toBigInt(bT)), toBigInt(cs), au))
429	429		let cC = fraction((cn - cB), at, cB)
430	430		$Tuple7(cn, cz, cA, be, cw, aC, cC)
431	431		}
432	432
433	433
434	434		func cE (bO,bP,bQ,bR,bS,bT,cs,aZ,bL,bM,ct) = {
435	435		let cF = bN(bO, bP, bQ, bR, bS, bT, cs)
436	436		let cG = cF._1
437	437		let ck = cF._2
438	438		let cl = cF._3
439	439		let ci = cF._4
440	440		let cj = cF._5
441	441		if ((ck > 0))
442	442		then {
443	443		let cH = cp(ck, cl, bQ, bR, (bS + ci), (bT + cj), cs, aZ, bL, bM, ct)
444	444		let cI = cH._1
445	445		let cz = cH._2
446	446		let cA = cH._3
447	447		let be = cH._4
448	448		let cw = cH._5
449	449		let cJ = cH._6
450	450		let cC = cH._7
451	451		$Tuple7((cG + cI), cC, cz, cA, be, cw, cJ)
452	452		}
453	453		else $Tuple7(cG, 0, (bS + ci), (bT + cj), 0, 0, unit)
454	454		}
455	455
456	456
457	457		@Callable(aF)
458	458		func calcLPReplenishDiffPropREADONLY (cK,cL,cM,cN) = {
459	459		let cO = bE(aF.caller)
460	460		let bF = cO._1
461	461		let bG = cO._2
462	462		let bu = cO._3
463	463		let bv = cO._4
464	464		let bH = cO._5
465	465		let cP = bA(aF.caller, bu, bv)
466	466		let bS = cP._1
467	467		let bT = cP._2
468	468		let cQ = cP._3
469	469		let cR = cP._4
470	470		let cs = bD(aF.caller)
471	471		let bO = parseIntValue(cL[0])
472	472		let bP = parseIntValue(cL[1])
473	473		let ct = parseIntValue(cL[2])
474	474		let cS = bI(aF.caller, aF.originCaller)
475	475		let aZ = cS._1
476	476		let bL = cS._2
477	477		let bM = cS._3
478	478		let cT = cE(bO, bP, bu, bv, bS, bT, cs, aZ, bL, bM, ct)
479	479		let cU = cT._1
480	480		let cC = cT._2
481	481		let cz = cT._3
482	482		let cA = cT._4
483	483		let be = cT._5
484	484		let cw = cT._6
485	485		let aC = cT._7
486	486		$Tuple2(nil, $Tuple2(nil, [cU, cC, cz, cA, be, cw, aC]))
487	487		}
488	488
489	489
490	490
491	491		@Callable(aF)
492	492		func calcLPReplenishTwoTokensREADONLY (cK,cL,cM,cN) = {
493	493		let cV = bE(aF.caller)
494	494		let bF = cV._1
495	495		let bG = cV._2
496	496		let bu = cV._3
497	497		let bv = cV._4
498	498		let bH = cV._5
499	499		let cW = bA(aF.caller, bu, bv)

github/deemru/w8io/169f3d6 
109.46 ms ◑