w8 · tx · 6jA···d3U

tx · 6jA3yWbKPoHCx6LkM23kJrgaTaJtHUB2dD1erLLMTd3U

3MrRa3KaEgRyyjQdMLuU78m5GkJLvP5DZLj:  -0.05100000 Waves

2022.08.16 23:45 [2187524] smart account 3MrRa3KaEgRyyjQdMLuU78m5GkJLvP5DZLj > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6jA3yWbKPoHCx6LkM23kJrgaTaJtHUB2dD1erLLMTd3U",
    "fee": 5100000,
    "feeAssetId": null,
    "timestamp": 1660682764827,
    "version": 2,
    "chainId": 84,
    "sender": "3MrRa3KaEgRyyjQdMLuU78m5GkJLvP5DZLj",
    "senderPublicKey": "AJNTN7EtP9dsAmPzcKRp9bRMvzZL4uwkmVxQuFuar3Qr",
    "proofs": [
        "5hRPnTpoXRR8mQad6XKk1LsAM2iTCPecgVY17h9rde8Ncnd47CeqeSrMq7mJDUPUVMxFYwnAbHMJaeaQV3J7Wbtr"
    ],
    "script": "base64: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",
    "height": 2187524,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2wQQjNpAEKfYNuVtRSvSRV1aJXBgThsEJUMTzhsCwnT5
Next: Ehsz59tFRahrbrmvuUU6tyHrXcS3kaT9CAFX8f4kfMsT

Diff: 
Old New Differences
309 309  func bD (by,bz) = {
310 310      let bE = aR()
311 311      let bF = aS()
312 -     let bG = ak(bE, bF)
313 -     let bH = ak(bz, bG)
314 312      let aN = am(bE, bF)
315 -     let bI = if (by)
313 +     let bG = if (by)
316 314          then (bE + bz)
317 315          else (bE - bz)
318 -     let bJ = ak(aN, bI)
319 -     let bK = an((bJ - bF))
320 -     let bL = if (by)
321 -         then bK
322 -         else -(bK)
323 -     let bM = an((ak(bH, bK) - ad))
324 -     let bN = bd()
325 -     if ((bM > bN))
326 -         then throw(((((((((((((("Price impact " + toString(bM)) + " > max price impact ") + toString(bN)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " ideal price buy: ") + toString(bH)) + " real price buy: ") + toString(bK)))
316 +     let bH = ak(aN, bG)
317 +     let bI = an((bH - bF))
318 +     let bJ = if (by)
319 +         then bI
320 +         else -(bI)
321 +     let bK = bx(by, bz, bI)
322 +     let bL = bK._1
323 +     let bM = bK._2
324 +     let bN = bK._3
325 +     let bO = bK._4
326 +     let bP = ak(bE, bF)
327 +     let bQ = ak(bz, bI)
328 +     let bR = an((bP - bQ))
329 +     let bS = (ad - ak(bP, (bP + bR)))
330 +     let bT = bd()
331 +     if ((bS > bT))
332 +         then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " price before: ") + toString(bP)) + " marketPrice: ") + toString(bQ)))
333 +         else $Tuple5(bJ, bL, bM, bN, bO)
334 +     }
335 + 
336 + 
337 + func bU (bV,bW,bX,bY) = {
338 +     let bZ = if ((bV != 0))
339 +         then {
340 +             let ca = bn(bV)
341 +             am((ca - bX), bV)
342 +             }
343 +         else 0
344 +     let cb = ((bY - bZ) + bW)
345 +     let cc = if ((0 > cb))
346 +         then $Tuple2(0, an(cb))
347 +         else $Tuple2(an(cb), 0)
348 +     let cd = cc._1
349 +     let ce = cc._2
350 +     $Tuple3(cd, ce, bZ)
351 +     }
352 + 
353 + 
354 + func cf (by,bA,cg) = {
355 +     let ch = aR()
356 +     let ci = aS()
357 +     let bP = ak(ch, ci)
358 +     if ((bA == 0))
359 +         then throw("Invalid base asset amount")
327 360          else {
328 -             let bO = bx(by, bz, bK)
329 -             let bP = bO._1
330 -             let bQ = bO._2
331 -             let bR = bO._3
332 -             let bS = bO._4
333 -             $Tuple5(bL, bP, bQ, bR, bS)
361 +             let aN = am(ch, ci)
362 +             let cj = if (by)
363 +                 then (ci + bA)
364 +                 else (ci - bA)
365 +             let ck = ak(aN, cj)
366 +             let cl = an((ck - ch))
367 +             let bT = bd()
368 +             let cm = bx(!(by), cl, bA)
369 +             let bL = cm._1
370 +             let bM = cm._2
371 +             let bN = cm._3
372 +             let bO = cm._4
373 +             let bQ = ak(cl, bA)
374 +             let bR = an((bP - bQ))
375 +             let bS = (ad - ak(bP, (bP + bR)))
376 +             if (if ((bS > bT))
377 +                 then cg
378 +                 else false)
379 +                 then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(ch)) + " before base asset: ") + toString(ci)) + " base asset amount to exchange: ") + toString(bA)) + " price before: ") + toString(bP)) + " market price: ") + toString(bQ)))
380 +                 else $Tuple7(cl, bL, bM, bN, bO, (bh() - (if (by)
381 +                     then an(bA)
382 +                     else 0)), (bg() - (if (!(by))
383 +                     then an(bA)
384 +                     else 0)))
334 385              }
335 386      }
336 387  
337 388  
338 - func bT (bU,bV,bW,bX) = {
339 -     let bY = if ((bU != 0))
340 -         then {
341 -             let bZ = bn(bU)
342 -             am((bZ - bW), bU)
343 -             }
344 -         else 0
345 -     let ca = ((bX - bY) + bV)
346 -     let cb = if ((0 > ca))
347 -         then $Tuple2(0, an(ca))
348 -         else $Tuple2(an(ca), 0)
349 -     let cc = cb._1
350 -     let cd = cb._2
351 -     $Tuple3(cc, cd, bY)
389 + func cn () = {
390 +     let co = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
391 +     let cp = getStringValue(this, a)
392 +     let cq = getStringValue(this, b)
393 +     let cr = valueOrErrorMessage(getInteger(co, cp), ((("Can not get oracle price. Oracle: " + toString(co)) + " key: ") + cp))
394 +     cr
352 395      }
353 396  
354 397  
355 - func ce (by,bA) = {
356 -     let cf = aR()
357 -     let cg = aS()
358 -     if ((bA == 0))
359 -         then throw("Invalid base asset amount")
398 + func cs () = {
399 +     let ch = aR()
400 +     let ci = aS()
401 +     ak(ch, ci)
402 +     }
403 + 
404 + 
405 + func ct () = {
406 +     let cu = cn()
407 +     let cv = cs()
408 +     (ak(an((cu - cv)), cu) > bc())
409 +     }
410 + 
411 + 
412 + func cw (bq,cx) = {
413 +     let cy = bp(bq)
414 +     let bt = cy._1
415 +     let cz = cy._2
416 +     let cA = cy._3
417 +     let cB = cy._4
418 +     let cC = an(bt)
419 +     if ((cC == 0))
420 +         then throw("Invalid position size")
360 421          else {
361 -             let aN = am(cf, cg)
362 -             let ch = if (by)
363 -                 then (cg + bA)
364 -                 else (cg - bA)
365 -             let ci = ak(aN, ch)
366 -             let cj = an((ci - cf))
367 -             let ck = bx(!(by), cj, bA)
368 -             let bP = ck._1
369 -             let bQ = ck._2
370 -             let bR = ck._3
371 -             let bS = ck._4
372 -             $Tuple7(cj, bP, bQ, bR, bS, (bh() - (if (by)
373 -                 then an(bA)
374 -                 else 0)), (bg() - (if (!(by))
375 -                 then an(bA)
376 -                 else 0)))
422 +             let cD = (0 > bt)
423 +             let cE = if ((cx == ag))
424 +                 then {
425 +                     let cF = cf(!(cD), cC, false)
426 +                     let cG = cF._1
427 +                     let cH = cF._2
428 +                     let cI = cF._3
429 +                     let cJ = cF._4
430 +                     cG
431 +                     }
432 +                 else am(cC, cn())
433 +             let cK = if (cD)
434 +                 then (cA - cE)
435 +                 else (cE - cA)
436 +             $Tuple2(cE, cK)
377 437              }
378 438      }
379 439  
380 440  
381 - func cl () = {
382 -     let cm = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
383 -     let cn = getStringValue(this, a)
384 -     let co = getStringValue(this, b)
385 -     let cp = valueOrErrorMessage(getInteger(cm, cn), ((("Can not get oracle price. Oracle: " + toString(cm)) + " key: ") + cn))
386 -     cp
441 + func cL (cM,cN,cO) = ak((cM - cN), cO)
442 + 
443 + 
444 + func cP (bq,cx) = {
445 +     let cQ = bp(bq)
446 +     let bt = cQ._1
447 +     let cz = cQ._2
448 +     let cR = cQ._3
449 +     let cB = cQ._4
450 +     let cS = cw(bq, cx)
451 +     let cE = cS._1
452 +     let cK = cS._2
453 +     let cT = bU(bt, cz, cB, cK)
454 +     let cd = cT._1
455 +     let ce = cT._2
456 +     cL(cd, ce, cE)
387 457      }
388 458  
389 459  
390 - func cq () = {
391 -     let cf = aR()
392 -     let cg = aS()
393 -     ak(cf, cg)
460 + func cU (bq) = cP(bq, ag)
461 + 
462 + 
463 + func cV (bq,cg) = {
464 +     let cW = bp(bq)
465 +     let bt = cW._1
466 +     let cz = cW._2
467 +     let cA = cW._3
468 +     let cB = cW._4
469 +     let cX = cw(bq, ag)
470 +     let cH = cX._1
471 +     let cK = cX._2
472 +     let cY = bU(bt, cz, cB, cK)
473 +     let cd = cY._1
474 +     let ce = cY._2
475 +     let cZ = -(bt)
476 +     let da = cK
477 +     let db = -(cd)
478 +     let dc = cf((bt > 0), an(bt), cg)
479 +     let dd = dc._1
480 +     let bG = dc._2
481 +     let bH = dc._3
482 +     let de = dc._4
483 +     let df = dc._5
484 +     let dg = dc._6
485 +     let dh = dc._7
486 +     let di = (aV() - cA)
487 +     $Tuple12(cZ, ce, da, db, bG, bH, de, df, di, dd, dg, dh)
394 488      }
395 489  
396 490  
397 - func cr () = {
398 -     let cs = cl()
399 -     let ct = cq()
400 -     (ak(an((cs - ct)), cs) > bc())
401 -     }
402 - 
403 - 
404 - func cu (bq,cv) = {
405 -     let cw = bp(bq)
406 -     let bt = cw._1
407 -     let cx = cw._2
408 -     let cy = cw._3
409 -     let cz = cw._4
410 -     let cA = an(bt)
411 -     if ((cA == 0))
412 -         then throw("Invalid position size")
413 -         else {
414 -             let cB = (0 > bt)
415 -             let cC = if ((cv == ag))
416 -                 then {
417 -                     let cD = ce(!(cB), cA)
418 -                     let cE = cD._1
419 -                     let cF = cD._2
420 -                     let cG = cD._3
421 -                     let cH = cD._4
422 -                     cE
423 -                     }
424 -                 else am(cA, cl())
425 -             let cI = if (cB)
426 -                 then (cy - cC)
427 -                 else (cC - cy)
428 -             $Tuple2(cC, cI)
429 -             }
430 -     }
431 - 
432 - 
433 - func cJ (cK,cL,cM) = ak((cK - cL), cM)
434 - 
435 - 
436 - func cN (bq,cv) = {
437 -     let cO = bp(bq)
438 -     let bt = cO._1
439 -     let cx = cO._2
440 -     let cP = cO._3
441 -     let cz = cO._4
442 -     let cQ = cu(bq, cv)
443 -     let cC = cQ._1
444 -     let cI = cQ._2
445 -     let cR = bT(bt, cx, cz, cI)
446 -     let cc = cR._1
447 -     let cd = cR._2
448 -     cJ(cc, cd, cC)
449 -     }
450 - 
451 - 
452 - func cS (bq) = cN(bq, ag)
453 - 
454 - 
455 - func cT (bq) = {
456 -     let cU = bp(bq)
457 -     let bt = cU._1
458 -     let cx = cU._2
459 -     let cy = cU._3
460 -     let cz = cU._4
461 -     let cV = cu(bq, ag)
462 -     let cF = cV._1
463 -     let cI = cV._2
464 -     let cW = bT(bt, cx, cz, cI)
465 -     let cc = cW._1
466 -     let cd = cW._2
467 -     let cX = -(bt)
468 -     let cY = cI
469 -     let cZ = -(cc)
470 -     let da = ce((bt > 0), an(bt))
471 -     let db = da._1
472 -     let bI = da._2
473 -     let bJ = da._3
474 -     let dc = da._4
475 -     let dd = da._5
476 -     let de = da._6
477 -     let df = da._7
478 -     let dg = (aV() - cy)
479 -     $Tuple12(cX, cd, cY, cZ, bI, bJ, dc, dd, dg, db, de, df)
480 -     }
481 - 
482 - 
483 - func dh () = {
484 -     let di = ((lastBlock.timestamp / 1000) / 60)
485 -     let dj = (di - aa)
486 -     let dk = valueOrElse(getString(this, r), "")
487 -     let dl = split(dk, ",")
488 -     func dm (av,dn) =     if ((dj >= parseIntValue(dn)))
489 -         then (av :+ parseIntValue(dn))
491 + func dj () = {
492 +     let dk = ((lastBlock.timestamp / 1000) / 60)
493 +     let dl = (dk - aa)
494 +     let dm = valueOrElse(getString(this, r), "")
495 +     let dn = split(dm, ",")
496 +     func do (av,dp) =     if ((dl >= parseIntValue(dp)))
497 +         then (av :+ parseIntValue(dp))
490 498          else av
491 499  
492 -     let do = {
493 -         let ay = dl
500 +     let dq = {
501 +         let ay = dn
494 502          let az = size(ay)
495 503          let aA = nil
496 504          func aB (aC,aD) =         if ((aD >= az))
497 505              then aC
498 -             else dm(aC, ay[aD])
506 +             else do(aC, ay[aD])
499 507  
500 508          func aE (aC,aD) =         if ((aD >= az))
501 509              then aC
503 511  
504 512          aE(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aA, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
505 513          }
506 -     let dp = if ((size(do) > 0))
507 -         then max(do)
508 -         else parseIntValue(dl[0])
509 -     let dq = valueOrElse(getInteger(this, s), 0)
510 -     let dr = valueOrElse(getInteger(this, ((t + "_") + toString(dq))), 0)
511 -     let ds = valueOrElse(getInteger(this, ((u + "_") + toString(dq))), 0)
512 -     let dt = (dr + ((di - dq) * ds))
513 -     let du = valueOrElse(getInteger(this, ((t + "_") + toString(dp))), 0)
514 -     let dv = valueOrElse(getInteger(this, ((u + "_") + toString(dp))), 0)
515 -     let dw = (du + ((dj - dp) * dv))
516 -     ((dt - dw) / aa)
514 +     let dr = if ((size(dq) > 0))
515 +         then max(dq)
516 +         else parseIntValue(dn[0])
517 +     let ds = valueOrElse(getInteger(this, s), 0)
518 +     let dt = valueOrElse(getInteger(this, ((t + "_") + toString(ds))), 0)
519 +     let du = valueOrElse(getInteger(this, ((u + "_") + toString(ds))), 0)
520 +     let dv = (dt + ((dk - ds) * du))
521 +     let dw = valueOrElse(getInteger(this, ((t + "_") + toString(dr))), 0)
522 +     let dx = valueOrElse(getInteger(this, ((u + "_") + toString(dr))), 0)
523 +     let dy = (dw + ((dl - dr) * dx))
524 +     ((dv - dy) / aa)
517 525      }
518 526  
519 527  
520 - func dx (dy,dz,dA,dB,dC,dD,dE) = [IntegerEntry(m, dy), IntegerEntry(n, dz), IntegerEntry(o, dA), IntegerEntry(l, dB), IntegerEntry(k, dC), IntegerEntry(p, dD), IntegerEntry(q, dE)]
528 + func dz (dA,dB,dC,dD,dE,dF,dG) = [IntegerEntry(m, dA), IntegerEntry(n, dB), IntegerEntry(o, dC), IntegerEntry(l, dD), IntegerEntry(k, dE), IntegerEntry(p, dF), IntegerEntry(q, dG)]
521 529  
522 530  
523 - func dF (dG,dH,dI,dJ,dK) = [IntegerEntry(y, dG), IntegerEntry(w, dH), IntegerEntry(x, dI), IntegerEntry(z, dJ), IntegerEntry(A, dK)]
531 + func dH (dI,dJ,dK,dL,dM) = [IntegerEntry(y, dI), IntegerEntry(w, dJ), IntegerEntry(x, dK), IntegerEntry(z, dL), IntegerEntry(A, dM)]
524 532  
525 533  
526 - func dL (ar,dM,dN,dO,bZ) = [IntegerEntry(ap(e, ar), dM), IntegerEntry(ap(f, ar), dN), IntegerEntry(ap(g, ar), dO), IntegerEntry(ap(h, ar), bZ)]
534 + func dN (ar,dO,dP,dQ,ca) = [IntegerEntry(ap(e, ar), dO), IntegerEntry(ap(f, ar), dP), IntegerEntry(ap(g, ar), dQ), IntegerEntry(ap(h, ar), ca)]
527 535  
528 536  
529 - func dP (dQ) = {
530 -     let di = ((lastBlock.timestamp / 1000) / 60)
531 -     let dR = valueOrElse(getInteger(this, s), 0)
532 -     if ((dR > di))
537 + func dR (dS) = {
538 +     let dk = ((lastBlock.timestamp / 1000) / 60)
539 +     let dT = valueOrElse(getInteger(this, s), 0)
540 +     if ((dT > dk))
533 541          then throw("TWAP out-of-order")
534 542          else {
535 -             let dq = if ((dR == 0))
536 -                 then di
537 -                 else dR
538 -             if ((di > dR))
543 +             let ds = if ((dT == 0))
544 +                 then dk
545 +                 else dT
546 +             if ((dk > dT))
539 547                  then {
540 -                     let dS = valueOrElse(getInteger(this, ((t + "_") + toString(dR))), 0)
541 -                     let dT = valueOrElse(getInteger(this, ((u + "_") + toString(dR))), dQ)
542 -                     let dU = (dS + ((di - dq) * dT))
543 -                     let dl = aJ(aH(valueOrElse(getString(this, r), "")), aa, toString(di))
544 - [IntegerEntry(ap(t, toString(di)), dU), IntegerEntry(ap(u, toString(di)), dQ), IntegerEntry(ap(v, toString(di)), dR), IntegerEntry(s, di), StringEntry(r, as(dl))]
548 +                     let dU = valueOrElse(getInteger(this, ((t + "_") + toString(dT))), 0)
549 +                     let dV = valueOrElse(getInteger(this, ((u + "_") + toString(dT))), dS)
550 +                     let dW = (dU + ((dk - ds) * dV))
551 +                     let dn = aJ(aH(valueOrElse(getString(this, r), "")), aa, toString(dk))
552 + [IntegerEntry(ap(t, toString(dk)), dW), IntegerEntry(ap(u, toString(dk)), dS), IntegerEntry(ap(v, toString(dk)), dT), IntegerEntry(s, dk), StringEntry(r, as(dn))]
545 553                      }
546 554                  else {
547 -                     let dV = valueOrElse(getInteger(this, ap(v, toString(di))), 0)
548 -                     let dS = valueOrElse(getInteger(this, ap(t, toString(dV))), 0)
549 -                     let dT = valueOrElse(getInteger(this, ap(u, toString(dV))), dQ)
550 -                     let dU = (dS + ((di - dV) * dT))
551 - [IntegerEntry(ap(t, toString(di)), dU), IntegerEntry(ap(u, toString(di)), dQ)]
555 +                     let dX = valueOrElse(getInteger(this, ap(v, toString(dk))), 0)
556 +                     let dU = valueOrElse(getInteger(this, ap(t, toString(dX))), 0)
557 +                     let dV = valueOrElse(getInteger(this, ap(u, toString(dX))), dS)
558 +                     let dW = (dU + ((dk - dX) * dV))
559 + [IntegerEntry(ap(t, toString(dk)), dW), IntegerEntry(ap(u, toString(dk)), dS)]
552 560                      }
553 561              }
554 562      }
555 563  
556 564  
557 - func dW (bE,bF) = [IntegerEntry(B, bE), IntegerEntry(C, bF)]
565 + func dY (bE,bF) = [IntegerEntry(B, bE), IntegerEntry(C, bF)]
558 566  
559 567  
560 - func dX (bE,bF,dY,dZ,ea,eb,ec) = if (((eb - ec) != dY))
561 -     then throw(((((("Invalid AMM state data: " + toString(eb)) + " +  ") + toString(ec)) + " != ") + toString(dY)))
562 -     else ((dW(bE, bF) ++ [IntegerEntry(D, dY), IntegerEntry(G, dZ), IntegerEntry(H, ea), IntegerEntry(E, eb), IntegerEntry(F, ec)]) ++ dP(ak(bE, bF)))
568 + func dZ (bE,bF,ea,eb,ec,ed,ee) = if (((ed - ee) != ea))
569 +     then throw(((((("Invalid AMM state data: " + toString(ed)) + " +  ") + toString(ee)) + " != ") + toString(ea)))
570 +     else ((dY(bE, bF) ++ [IntegerEntry(D, ea), IntegerEntry(G, eb), IntegerEntry(H, ec), IntegerEntry(E, ed), IntegerEntry(F, ee)]) ++ dR(ak(bE, bF)))
563 571  
564 572  
565 - func ed (ar) = [DeleteEntry(ap(e, ar)), DeleteEntry(ap(f, ar)), DeleteEntry(ap(g, ar)), DeleteEntry(ap(h, ar))]
573 + func ef (ar) = [DeleteEntry(ap(e, ar)), DeleteEntry(ap(f, ar)), DeleteEntry(ap(g, ar)), DeleteEntry(ap(h, ar))]
566 574  
567 575  
568 - func ee (ar,ef) = {
569 -     let eg = assetBalance(this, T())
570 -     if ((ef > eg))
571 -         then throw(((("Unable to withdraw " + toString(ef)) + " from contract balance ") + toString(eg)))
572 -         else [ScriptTransfer(ar, ef, T())]
576 + func eg (ar,eh) = {
577 +     let ei = assetBalance(this, T())
578 +     if ((eh > ei))
579 +         then throw(((("Unable to withdraw " + toString(eh)) + " from contract balance ") + toString(ei)))
580 +         else [ScriptTransfer(ar, eh, T())]
573 581      }
574 582  
575 583  
576 - func eh (ei) = if ((0 > ei))
584 + func ej (ek) = if ((0 > ek))
577 585      then throw("Balance")
578 -     else [IntegerEntry(d, ei)]
586 +     else [IntegerEntry(d, ek)]
579 587  
580 588  
581 - func ej (ei) = [ScriptTransfer(V(), ei, T())]
589 + func el (ek) = [ScriptTransfer(V(), ek, T())]
582 590  
583 591  
584 - @Callable(ei)
585 - func pause () = if ((ei.caller != R()))
592 + @Callable(ek)
593 + func pause () = if ((ek.caller != R()))
586 594      then throw("Invalid togglePause params")
587 595      else [BooleanEntry(j, true)]
588 596  
589 597  
590 598  
591 - @Callable(ei)
592 - func unpause () = if ((ei.caller != R()))
599 + @Callable(ek)
600 + func unpause () = if ((ek.caller != R()))
593 601      then throw("Invalid togglePause params")
594 602      else [BooleanEntry(j, false)]
595 603  
596 604  
597 605  
598 - @Callable(ei)
599 - func addLiquidity (bz) = if (if ((ei.caller != R()))
606 + @Callable(ek)
607 + func addLiquidity (bz) = if (if ((ek.caller != R()))
600 608      then true
601 609      else (0 >= bz))
602 610      then throw("Invalid addLiquidity params")
603 611      else {
604 612          let bE = aR()
605 613          let bF = aS()
606 -         let dQ = ak(bE, bF)
607 -         let ek = ak(bz, dQ)
608 -         let el = (bE + bz)
609 -         let em = (bF + ek)
610 -         dW(el, em)
614 +         let dS = ak(bE, bF)
615 +         let em = ak(bz, dS)
616 +         let en = (bE + bz)
617 +         let eo = (bF + em)
618 +         dY(en, eo)
611 619          }
612 620  
613 621  
614 622  
615 - @Callable(ei)
616 - func removeLiquidity (bz) = if (if ((ei.caller != R()))
623 + @Callable(ek)
624 + func removeLiquidity (bz) = if (if ((ek.caller != R()))
617 625      then true
618 626      else (0 >= bz))
619 627      then throw("Invalid removeLiquidity params")
620 628      else {
621 629          let bE = aR()
622 630          let bF = aS()
623 -         let dQ = ak(bE, bF)
624 -         let en = ak(bz, dQ)
625 -         let el = (bE - bz)
626 -         let em = (bF - en)
627 -         dW(el, em)
631 +         let dS = ak(bE, bF)
632 +         let ep = ak(bz, dS)
633 +         let en = (bE - bz)
634 +         let eo = (bF - ep)
635 +         dY(en, eo)
628 636          }
629 637  
630 638  
631 639  
632 - @Callable(ei)
633 - func changeSettings (dy,dz,dA,dB,dC,dD,dE) = if ((ei.caller != R()))
640 + @Callable(ek)
641 + func changeSettings (dA,dB,dC,dD,dE,dF,dG) = if ((ek.caller != R()))
634 642      then throw("Invalid changeSettings params")
635 -     else dx(dy, dz, dA, dB, dC, dD, dE)
643 +     else dz(dA, dB, dC, dD, dE, dF, dG)
636 644  
637 645  
638 646  
639 - @Callable(ei)
640 - func initialize (bE,bF,dB,dy,dz,dA,dC,eo,ep,eq,dD,dE) = if (if (if (if (if (if (if (if (if (if ((0 >= bE))
647 + @Callable(ek)
648 + func initialize (bE,bF,dD,dA,dB,dC,dE,eq,er,es,dF,dG) = if (if (if (if (if (if (if (if (if (if ((0 >= bE))
641 649      then true
642 650      else (0 >= bF))
643 651      then true
644 -     else (0 >= dB))
645 -     then true
646 -     else (0 >= dy))
647 -     then true
648 -     else (0 >= dz))
652 +     else (0 >= dD))
649 653      then true
650 654      else (0 >= dA))
651 655      then true
656 +     else (0 >= dB))
657 +     then true
652 658      else (0 >= dC))
653 -     then true
654 -     else (0 >= dD))
655 659      then true
656 660      else (0 >= dE))
657 661      then true
662 +     else (0 >= dF))
663 +     then true
664 +     else (0 >= dG))
665 +     then true
658 666      else bv())
659 667      then throw("Invalid initialize parameters")
660 -     else ((((dX(bE, bF, 0, 0, 0, 0, 0) ++ dx(dy, dz, dA, dB, dC, dD, dE)) ++ dF((lastBlock.timestamp + dB), 0, 0, 0, 0)) ++ eh(0)) ++ [BooleanEntry(i, true), StringEntry(c, eo), StringEntry(a, ep), StringEntry(I, eq)])
668 +     else ((((dZ(bE, bF, 0, 0, 0, 0, 0) ++ dz(dA, dB, dC, dD, dE, dF, dG)) ++ dH((lastBlock.timestamp + dD), 0, 0, 0, 0)) ++ ej(0)) ++ [BooleanEntry(i, true), StringEntry(c, eq), StringEntry(a, er), StringEntry(I, es)])
661 669  
662 670  
663 671  
664 - @Callable(ei)
665 - func decreasePosition (ef,er,es) = if (if (if (if (if ((0 >= ef))
672 + @Callable(ek)
673 + func decreasePosition (eh,et,eu) = if (if (if (if (if ((0 >= eh))
666 674      then true
667 675      else !(bv()))
668 676      then true
669 -     else !(bi(ak(ad, er), aQ(), true)))
677 +     else !(bi(ak(ad, et), aQ(), true)))
670 678      then true
671 -     else !(bu(toString(ei.caller))))
679 +     else !(bu(toString(ek.caller))))
672 680      then true
673 681      else bw())
674 682      then throw("Invalid decreasePosition parameters")
675 683      else {
676 -         let et = bp(toString(ei.caller))
677 -         let eu = et._1
678 -         let ev = et._2
679 -         let ew = et._3
680 -         let ex = et._4
681 -         let ey = if ((eu > 0))
684 +         let ev = bp(toString(ek.caller))
685 +         let ew = ev._1
686 +         let ex = ev._2
687 +         let ey = ev._3
688 +         let ez = ev._4
689 +         let eA = if ((ew > 0))
682 690              then Z
683 691              else Y
684 -         let ez = (ey == Y)
685 -         let eA = am(ef, er)
686 -         let eB = cu(toString(ei.caller), ag)
687 -         let eC = eB._1
688 -         let cI = eB._2
689 -         let eD = if ((eC > eA))
692 +         let eB = (eA == Y)
693 +         let eC = am(eh, et)
694 +         let eD = cw(toString(ek.caller), ag)
695 +         let eE = eD._1
696 +         let cK = eD._2
697 +         let eF = if ((eE > eC))
690 698              then {
691 -                 let eE = bD(ez, eA)
692 -                 let cX = eE._1
693 -                 let bI = eE._2
694 -                 let bJ = eE._3
695 -                 let dc = eE._4
696 -                 let dd = eE._5
697 -                 let eF = an(cX)
698 -                 if (if ((es != 0))
699 -                     then (es > eF)
699 +                 let eG = bD(eB, eC)
700 +                 let cZ = eG._1
701 +                 let bG = eG._2
702 +                 let bH = eG._3
703 +                 let de = eG._4
704 +                 let df = eG._5
705 +                 let eH = an(cZ)
706 +                 if (if ((eu != 0))
707 +                     then (eu > eH)
700 708                      else false)
701 -                     then throw(((("Too little base asset exchanged, got " + toString(eF)) + " expected ") + toString(es)))
709 +                     then throw(((("Too little base asset exchanged, got " + toString(eH)) + " expected ") + toString(eu)))
702 710                      else {
703 -                         let cY = ak(am(cI, eF), an(eu))
704 -                         let eG = bT(eu, ev, ex, cY)
705 -                         let cc = eG._1
706 -                         let cd = eG._2
707 -                         let bY = eG._3
708 -                         let db = eA
709 -                         let eH = (cI - cY)
710 -                         let eI = if ((eu > 0))
711 -                             then ((eC - db) - eH)
712 -                             else ((eH + eC) - db)
713 -                         let eJ = (eu + cX)
714 -                         $Tuple11(eJ, cc, an(eI), bn(eJ), bJ, bI, dc, dd, (aV() - eA), (bh() - (if ((eJ > 0))
715 -                             then an(cX)
716 -                             else 0)), (bg() - (if ((0 > eJ))
717 -                             then an(cX)
711 +                         let da = ak(am(cK, eH), an(ew))
712 +                         let eI = bU(ew, ex, ez, da)
713 +                         let cd = eI._1
714 +                         let ce = eI._2
715 +                         let bZ = eI._3
716 +                         let dd = eC
717 +                         let eJ = (cK - da)
718 +                         let eK = if ((ew > 0))
719 +                             then ((eE - dd) - eJ)
720 +                             else ((eJ + eE) - dd)
721 +                         let eL = (ew + cZ)
722 +                         $Tuple11(eL, cd, an(eK), bn(eL), bH, bG, de, df, (aV() - eC), (bh() - (if ((eL > 0))
723 +                             then an(cZ)
724 +                             else 0)), (bg() - (if ((0 > eL))
725 +                             then an(cZ)
718 726                              else 0)))
719 727                          }
720 728                  }
721 729              else throw("Close position first")
722 -         let eJ = eD._1
723 -         let eK = eD._2
724 -         let eL = eD._3
725 -         let eM = eD._4
726 -         let bJ = eD._5
727 -         let bI = eD._6
728 -         let dc = eD._7
729 -         let dd = eD._8
730 -         let dg = eD._9
731 -         let de = eD._10
732 -         let df = eD._11
733 -         let eN = invoke(X(), "notifyNotional", [toString(ei.caller), eL], nil)
734 -         if ((eN == eN))
735 -             then (dL(toString(ei.caller), eJ, eK, eL, eM) ++ dX(bI, bJ, dc, dd, dg, de, df))
730 +         let eL = eF._1
731 +         let eM = eF._2
732 +         let eN = eF._3
733 +         let eO = eF._4
734 +         let bH = eF._5
735 +         let bG = eF._6
736 +         let de = eF._7
737 +         let df = eF._8
738 +         let di = eF._9
739 +         let dg = eF._10
740 +         let dh = eF._11
741 +         let eP = invoke(X(), "notifyNotional", [toString(ek.caller), eN], nil)
742 +         if ((eP == eP))
743 +             then (dN(toString(ek.caller), eL, eM, eN, eO) ++ dZ(bG, bH, de, df, di, dg, dh))
736 744              else throw("Strict value is not equal to itself.")
737 745          }
738 746  
739 747  
740 748  
741 - @Callable(ei)
742 - func increasePosition (ey,er,es) = {
743 -     let eO = ei.payments[0].amount
744 -     if (if (if (if (if (if (if ((ey != Y))
745 -         then (ey != Z)
749 + @Callable(ek)
750 + func increasePosition (eA,et,eu) = {
751 +     let eQ = ek.payments[0].amount
752 +     if (if (if (if (if (if (if ((eA != Y))
753 +         then (eA != Z)
746 754          else false)
747 755          then true
748 -         else (0 >= eO))
756 +         else (0 >= eQ))
749 757          then true
750 758          else !(bv()))
751 759          then true
752 -         else (ei.payments[0].assetId != T()))
760 +         else (ek.payments[0].assetId != T()))
753 761          then true
754 -         else !(bi(ak(ad, er), aQ(), true)))
762 +         else !(bi(ak(ad, et), aQ(), true)))
755 763          then true
756 764          else bw())
757 765          then throw("Invalid increasePosition parameters")
758 766          else {
759 -             let eP = am(eO, aP())
760 -             let ef = (eO - eP)
761 -             let eQ = bp(toString(ei.caller))
762 -             let eu = eQ._1
763 -             let ev = eQ._2
764 -             let ew = eQ._3
765 -             let ex = eQ._4
766 -             let eR = (eu == 0)
767 -             let eS = if ((eu > 0))
768 -                 then (ey == Y)
769 -                 else (ey == Z)
770 -             let eT = if (!(eR))
771 -                 then eS
767 +             let eR = am(eQ, aP())
768 +             let eh = (eQ - eR)
769 +             let eS = bp(toString(ek.caller))
770 +             let ew = eS._1
771 +             let ex = eS._2
772 +             let ey = eS._3
773 +             let ez = eS._4
774 +             let eT = (ew == 0)
775 +             let eU = if ((ew > 0))
776 +                 then (eA == Y)
777 +                 else (eA == Z)
778 +             let eV = if (!(eT))
779 +                 then eU
772 780                  else false
773 -             let ez = (ey == Y)
774 -             let eU = if (if (eR)
781 +             let eB = (eA == Y)
782 +             let eW = if (if (eT)
775 783                  then true
776 -                 else eT)
784 +                 else eV)
777 785                  then {
778 -                     let eA = am(ef, er)
779 -                     let eV = bD(ez, eA)
780 -                     let bL = eV._1
781 -                     let bI = eV._2
782 -                     let bJ = eV._3
783 -                     let dc = eV._4
784 -                     let dd = eV._5
785 -                     if (if ((es != 0))
786 -                         then (es > an(bL))
786 +                     let eC = am(eh, et)
787 +                     let eX = bD(eB, eC)
788 +                     let bJ = eX._1
789 +                     let bG = eX._2
790 +                     let bH = eX._3
791 +                     let de = eX._4
792 +                     let df = eX._5
793 +                     if (if ((eu != 0))
794 +                         then (eu > an(bJ))
787 795                          else false)
788 -                         then throw(((("Limit error: " + toString(an(bL))) + " < ") + toString(es)))
796 +                         then throw(((("Limit error: " + toString(an(bJ))) + " < ") + toString(eu)))
789 797                          else {
790 -                             let eJ = (eu + bL)
791 -                             let eW = ak(eA, er)
792 -                             let eX = bT(eu, ev, ex, eW)
793 -                             let cc = eX._1
794 -                             let cF = eX._2
795 -                             let cG = eX._3
796 -                             $Tuple11(eJ, cc, (ew + eA), bn(eJ), bJ, bI, dc, dd, (aV() + eA), (bh() + (if ((eJ > 0))
797 -                                 then an(bL)
798 -                                 else 0)), (bg() + (if ((0 > eJ))
799 -                                 then an(bL)
798 +                             let eL = (ew + bJ)
799 +                             let eY = ak(eC, et)
800 +                             let eZ = bU(ew, ex, ez, eY)
801 +                             let cd = eZ._1
802 +                             let cH = eZ._2
803 +                             let cI = eZ._3
804 +                             $Tuple11(eL, cd, (ey + eC), bn(eL), bH, bG, de, df, (aV() + eC), (bh() + (if ((eL > 0))
805 +                                 then an(bJ)
806 +                                 else 0)), (bg() + (if ((0 > eL))
807 +                                 then an(bJ)
800 808                                  else 0)))
801 809                              }
802 810                      }
803 811                  else {
804 -                     let eA = am(ef, er)
805 -                     let eY = cu(toString(ei.caller), ag)
806 -                     let eC = eY._1
807 -                     let cI = eY._2
808 -                     if ((eC > eA))
812 +                     let eC = am(eh, et)
813 +                     let fa = cw(toString(ek.caller), ag)
814 +                     let eE = fa._1
815 +                     let cK = fa._2
816 +                     if ((eE > eC))
809 817                          then throw("Use decreasePosition to decrease position size")
810 818                          else throw("Close position first")
811 819                      }
812 -             let eJ = eU._1
813 -             let eK = eU._2
814 -             let eL = eU._3
815 -             let eM = eU._4
816 -             let bJ = eU._5
817 -             let bI = eU._6
818 -             let dc = eU._7
819 -             let dd = eU._8
820 -             let dg = eU._9
821 -             let de = eU._10
822 -             let df = eU._11
823 -             let eZ = (eP / 2)
824 -             let fa = (eP - eZ)
825 -             let fb = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), ef)])
826 -             if ((fb == fb))
820 +             let eL = eW._1
821 +             let eM = eW._2
822 +             let eN = eW._3
823 +             let eO = eW._4
824 +             let bH = eW._5
825 +             let bG = eW._6
826 +             let de = eW._7
827 +             let df = eW._8
828 +             let di = eW._9
829 +             let dg = eW._10
830 +             let dh = eW._11
831 +             let fb = (eR / 2)
832 +             let fc = (eR - fb)
833 +             let fd = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), eh)])
834 +             if ((fd == fd))
827 835                  then {
828 -                     let fc = invoke(W(), "deposit", nil, [AttachedPayment(T(), fa)])
829 -                     if ((fc == fc))
836 +                     let fe = invoke(W(), "deposit", nil, [AttachedPayment(T(), fc)])
837 +                     if ((fe == fe))
830 838                          then {
831 -                             let fd = invoke(X(), "notifyFees", [toString(ei.caller), eP], nil)
832 -                             if ((fd == fd))
839 +                             let ff = invoke(X(), "notifyFees", [toString(ek.caller), eR], nil)
840 +                             if ((ff == ff))
833 841                                  then {
834 -                                     let eN = invoke(X(), "notifyNotional", [toString(ei.caller), eL], nil)
835 -                                     if ((eN == eN))
836 -                                         then (((dL(toString(ei.caller), eJ, eK, eL, eM) ++ dX(bI, bJ, dc, dd, dg, de, df)) ++ ej(eZ)) ++ eh((aO() + ef)))
842 +                                     let eP = invoke(X(), "notifyNotional", [toString(ek.caller), eN], nil)
843 +                                     if ((eP == eP))
844 +                                         then (((dN(toString(ek.caller), eL, eM, eN, eO) ++ dZ(bG, bH, de, df, di, dg, dh)) ++ el(fb)) ++ ej((aO() + eh)))
837 845                                          else throw("Strict value is not equal to itself.")
838 846                                      }
839 847                                  else throw("Strict value is not equal to itself.")
846 854  
847 855  
848 856  
849 - @Callable(ei)
857 + @Callable(ek)
850 858  func addMargin () = {
851 -     let eO = ei.payments[0].amount
852 -     if (if (if (if ((ei.payments[0].assetId != T()))
859 +     let eQ = ek.payments[0].amount
860 +     if (if (if (if ((ek.payments[0].assetId != T()))
853 861          then true
854 -         else !(bu(toString(ei.caller))))
862 +         else !(bu(toString(ek.caller))))
855 863          then true
856 864          else !(bv()))
857 865          then true
858 866          else bw())
859 867          then throw("Invalid addMargin parameters")
860 868          else {
861 -             let eP = am(eO, aP())
862 -             let ef = (eO - eP)
863 -             let fe = bp(toString(ei.caller))
864 -             let eu = fe._1
865 -             let ev = fe._2
866 -             let ew = fe._3
867 -             let ex = fe._4
868 -             let eZ = (eP / 2)
869 -             let fa = (eP - eZ)
870 -             let fb = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), ef)])
871 -             if ((fb == fb))
869 +             let eR = am(eQ, aP())
870 +             let eh = (eQ - eR)
871 +             let fg = bp(toString(ek.caller))
872 +             let ew = fg._1
873 +             let ex = fg._2
874 +             let ey = fg._3
875 +             let ez = fg._4
876 +             let fb = (eR / 2)
877 +             let fc = (eR - fb)
878 +             let fd = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), eh)])
879 +             if ((fd == fd))
872 880                  then {
873 -                     let fc = invoke(W(), "deposit", nil, [AttachedPayment(T(), fa)])
874 -                     if ((fc == fc))
881 +                     let fe = invoke(W(), "deposit", nil, [AttachedPayment(T(), fc)])
882 +                     if ((fe == fe))
875 883                          then {
876 -                             let fd = invoke(X(), "notifyFees", [toString(ei.caller), eP], nil)
877 -                             if ((fd == fd))
878 -                                 then ((dL(toString(ei.caller), eu, (ev + ef), ew, ex) ++ ej(eZ)) ++ eh((aO() + ef)))
884 +                             let ff = invoke(X(), "notifyFees", [toString(ek.caller), eR], nil)
885 +                             if ((ff == ff))
886 +                                 then ((dN(toString(ek.caller), ew, (ex + eh), ey, ez) ++ el(fb)) ++ ej((aO() + eh)))
879 887                                  else throw("Strict value is not equal to itself.")
880 888                              }
881 889                          else throw("Strict value is not equal to itself.")
886 894  
887 895  
888 896  
889 - @Callable(ei)
890 - func removeMargin (ef) = if (if (if (if ((0 >= ef))
897 + @Callable(ek)
898 + func removeMargin (eh) = if (if (if (if ((0 >= eh))
891 899      then true
892 -     else !(bu(toString(ei.caller))))
900 +     else !(bu(toString(ek.caller))))
893 901      then true
894 902      else !(bv()))
895 903      then true
896 904      else bw())
897 905      then throw("Invalid removeMargin parameters")
898 906      else {
899 -         let ff = bp(toString(ei.caller))
900 -         let eu = ff._1
901 -         let ev = ff._2
902 -         let ew = ff._3
903 -         let ex = ff._4
904 -         let fg = -(ef)
905 -         let fh = bT(eu, ev, ex, fg)
906 -         let cc = fh._1
907 -         let cd = fh._2
908 -         if ((cd != 0))
907 +         let fh = bp(toString(ek.caller))
908 +         let ew = fh._1
909 +         let ex = fh._2
910 +         let ey = fh._3
911 +         let ez = fh._4
912 +         let fi = -(eh)
913 +         let fj = bU(ew, ex, ez, fi)
914 +         let cd = fj._1
915 +         let ce = fj._2
916 +         if ((ce != 0))
909 917              then throw("Invalid removed margin amount")
910 918              else {
911 -                 let fi = cJ(cc, cd, ew)
912 -                 if (!(bi(fi, aQ(), true)))
913 -                     then throw(((("Too much margin removed: " + toString(fi)) + " < ") + toString(aQ())))
919 +                 let fk = cL(cd, ce, ey)
920 +                 if (!(bi(fk, aQ(), true)))
921 +                     then throw(((("Too much margin removed: " + toString(fk)) + " < ") + toString(aQ())))
914 922                      else {
915 -                         let fj = invoke(U(), "unlockNeutrino", [ef, toBase58String(T())], nil)
916 -                         if ((fj == fj))
917 -                             then ((dL(toString(ei.caller), eu, cc, ew, bn(eu)) ++ ee(ei.caller, ef)) ++ eh((aO() - ef)))
923 +                         let fl = invoke(U(), "unlockNeutrino", [eh, toBase58String(T())], nil)
924 +                         if ((fl == fl))
925 +                             then ((dN(toString(ek.caller), ew, cd, ey, bn(ew)) ++ eg(ek.caller, eh)) ++ ej((aO() - eh)))
918 926                              else throw("Strict value is not equal to itself.")
919 927                          }
920 928                  }
922 930  
923 931  
924 932  
925 - @Callable(ei)
926 - func closePosition () = if (if (if (!(bu(toString(ei.caller))))
933 + @Callable(ek)
934 + func closePosition () = if (if (if (!(bu(toString(ek.caller))))
927 935      then true
928 936      else !(bv()))
929 937      then true
930 938      else bw())
931 939      then throw("Invalid closePosition parameters")
932 940      else {
933 -         let fk = cT(toString(ei.caller))
934 -         let cF = fk._1
935 -         let fl = fk._2
936 -         let cY = fk._3
937 -         let cZ = fk._4
938 -         let bI = fk._5
939 -         let bJ = fk._6
940 -         let dc = fk._7
941 -         let dd = fk._8
942 -         let dg = fk._9
943 -         let cG = fk._10
944 -         let de = fk._11
945 -         let df = fk._12
946 -         if ((fl > 0))
941 +         let fm = cV(toString(ek.caller), true)
942 +         let cH = fm._1
943 +         let fn = fm._2
944 +         let da = fm._3
945 +         let db = fm._4
946 +         let bG = fm._5
947 +         let bH = fm._6
948 +         let de = fm._7
949 +         let df = fm._8
950 +         let di = fm._9
951 +         let cI = fm._10
952 +         let dg = fm._11
953 +         let dh = fm._12
954 +         if ((fn > 0))
947 955              then throw("Unable to close position with bad debt")
948 956              else {
949 -                 let fm = an(cZ)
950 -                 let fn = (aO() - fm)
951 -                 let fo = if ((0 > fn))
952 -                     then $Tuple2(0, an(fn))
953 -                     else $Tuple2(fn, 0)
954 -                 let fp = fo._1
955 -                 let fq = fo._2
956 -                 let fr = if ((fq > 0))
957 +                 let fo = an(db)
958 +                 let fp = (aO() - fo)
959 +                 let fq = if ((0 > fp))
960 +                     then $Tuple2(0, an(fp))
961 +                     else $Tuple2(fp, 0)
962 +                 let fr = fq._1
963 +                 let fs = fq._2
964 +                 let ft = if ((fs > 0))
957 965                      then {
958 -                         let fs = invoke(W(), "withdraw", [fq], nil)
959 -                         if ((fs == fs))
966 +                         let fu = invoke(W(), "withdraw", [fs], nil)
967 +                         if ((fu == fu))
960 968                              then nil
961 969                              else throw("Strict value is not equal to itself.")
962 970                          }
963 971                      else nil
964 -                 if ((fr == fr))
972 +                 if ((ft == ft))
965 973                      then {
966 -                         let fj = invoke(U(), "unlockNeutrino", [(fm - fq), toBase58String(T())], nil)
967 -                         if ((fj == fj))
974 +                         let fl = invoke(U(), "unlockNeutrino", [(fo - fs), toBase58String(T())], nil)
975 +                         if ((fl == fl))
968 976                              then {
969 -                                 let eN = invoke(X(), "notifyNotional", [toString(ei.caller), 0], nil)
970 -                                 if ((eN == eN))
971 -                                     then (((ed(toString(ei.caller)) ++ dX(bI, bJ, dc, dd, dg, de, df)) ++ ee(ei.caller, fm)) ++ eh(fp))
977 +                                 let eP = invoke(X(), "notifyNotional", [toString(ek.caller), 0], nil)
978 +                                 if ((eP == eP))
979 +                                     then (((ef(toString(ek.caller)) ++ dZ(bG, bH, de, df, di, dg, dh)) ++ eg(ek.caller, fo)) ++ ej(fr))
972 980                                      else throw("Strict value is not equal to itself.")
973 981                                  }
974 982                              else throw("Strict value is not equal to itself.")
979 987  
980 988  
981 989  
982 - @Callable(ei)
990 + @Callable(ek)
983 991  func liquidate (bq) = {
984 -     let ft = cN(bq, ag)
985 -     let fi = if (cr())
992 +     let fv = cP(bq, ag)
993 +     let fk = if (ct())
986 994          then {
987 -             let fu = cN(bq, ah)
988 -             ao(ft, fu)
995 +             let fw = cP(bq, ah)
996 +             ao(fv, fw)
989 997              }
990 -         else ft
991 -     if (if (if (if (!(bi(fi, ba(), false)))
998 +         else fv
999 +     if (if (if (if (!(bi(fk, ba(), false)))
992 1000          then true
993 1001          else !(bu(bq)))
994 1002          then true
997 1005          else bw())
998 1006          then throw("Unable to liquidate")
999 1007          else {
1000 -             let fv = cT(bq)
1001 -             let cF = fv._1
1002 -             let cd = fv._2
1003 -             let cG = fv._3
1004 -             let cH = fv._4
1005 -             let bI = fv._5
1006 -             let bJ = fv._6
1007 -             let dc = fv._7
1008 -             let dd = fv._8
1009 -             let dg = fv._9
1010 -             let db = fv._10
1011 -             let de = fv._11
1012 -             let df = fv._12
1013 -             let fw = am(db, bb())
1014 -             let fx = (fw / 2)
1015 -             let fa = (fw - fx)
1016 -             let fn = (aO() - fw)
1017 -             let fy = if ((0 > fn))
1018 -                 then $Tuple2(0, an(fn))
1019 -                 else $Tuple2(fn, 0)
1020 -             let fz = fy._1
1021 -             let fA = fy._2
1022 -             let fr = if ((fA > 0))
1008 +             let fx = cV(bq, false)
1009 +             let cH = fx._1
1010 +             let ce = fx._2
1011 +             let cI = fx._3
1012 +             let cJ = fx._4
1013 +             let bG = fx._5
1014 +             let bH = fx._6
1015 +             let de = fx._7
1016 +             let df = fx._8
1017 +             let di = fx._9
1018 +             let dd = fx._10
1019 +             let dg = fx._11
1020 +             let dh = fx._12
1021 +             let fy = am(dd, bb())
1022 +             let fz = (fy / 2)
1023 +             let fc = (fy - fz)
1024 +             let fp = (aO() - fy)
1025 +             let fA = if ((0 > fp))
1026 +                 then $Tuple2(0, an(fp))
1027 +                 else $Tuple2(fp, 0)
1028 +             let fB = fA._1
1029 +             let fC = fA._2
1030 +             let ft = if ((fC > 0))
1023 1031                  then {
1024 -                     let fs = invoke(W(), "withdraw", [fA], nil)
1025 -                     if ((fs == fs))
1032 +                     let fu = invoke(W(), "withdraw", [fC], nil)
1033 +                     if ((fu == fu))
1026 1034                          then nil
1027 1035                          else throw("Strict value is not equal to itself.")
1028 1036                      }
1029 1037                  else nil
1030 -             if ((fr == fr))
1038 +             if ((ft == ft))
1031 1039                  then {
1032 -                     let fj = invoke(U(), "unlockNeutrino", [(fw - fA), toBase58String(T())], nil)
1033 -                     if ((fj == fj))
1040 +                     let fl = invoke(U(), "unlockNeutrino", [(fy - fC), toBase58String(T())], nil)
1041 +                     if ((fl == fl))
1034 1042                          then {
1035 -                             let fc = invoke(W(), "deposit", nil, [AttachedPayment(T(), fa)])
1036 -                             if ((fc == fc))
1043 +                             let fe = invoke(W(), "deposit", nil, [AttachedPayment(T(), fc)])
1044 +                             if ((fe == fe))
1037 1045                                  then {
1038 -                                     let eN = invoke(X(), "notifyNotional", [bq, 0], nil)
1039 -                                     if ((eN == eN))
1040 -                                         then (((ed(bq) ++ dX(bI, bJ, dc, dd, dg, de, df)) ++ ee(ei.caller, fx)) ++ eh(fz))
1046 +                                     let eP = invoke(X(), "notifyNotional", [bq, 0], nil)
1047 +                                     if ((eP == eP))
1048 +                                         then (((ef(bq) ++ dZ(bG, bH, de, df, di, dg, dh)) ++ eg(ek.caller, fz)) ++ ej(fB))
1041 1049                                          else throw("Strict value is not equal to itself.")
1042 1050                                      }
1043 1051                                  else throw("Strict value is not equal to itself.")
1050 1058  
1051 1059  
1052 1060  
1053 - @Callable(ei)
1061 + @Callable(ek)
1054 1062  func payFunding () = {
1055 -     let fB = aW()
1056 -     if (if (if ((fB > lastBlock.timestamp))
1063 +     let fD = aW()
1064 +     if (if (if ((fD > lastBlock.timestamp))
1057 1065          then true
1058 1066          else !(bv()))
1059 1067          then true
1060 1068          else bw())
1061 -         then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(fB)))
1069 +         then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(fD)))
1062 1070          else {
1063 -             let fC = cl()
1064 -             let fD = dh()
1065 -             let fE = (fD - fC)
1066 -             let fF = if (if ((bg() == 0))
1071 +             let fE = cn()
1072 +             let fF = dj()
1073 +             let fG = (fF - fE)
1074 +             let fH = if (if ((bg() == 0))
1067 1075                  then true
1068 1076                  else (bh() == 0))
1069 1077                  then $Tuple2(0, 0)
1070 -                 else if ((0 > fE))
1078 +                 else if ((0 > fG))
1071 1079                      then {
1072 -                         let fG = ak(am(fE, aY()), ae)
1073 -                         let fH = ak(am(fG, bg()), bh())
1074 -                         $Tuple2(fG, fH)
1080 +                         let fI = ak(am(fG, aY()), ae)
1081 +                         let fJ = ak(am(fI, bg()), bh())
1082 +                         $Tuple2(fI, fJ)
1075 1083                          }
1076 1084                      else {
1077 -                         let fH = ak(am(fE, aY()), ae)
1078 -                         let fG = ak(am(fH, bh()), bg())
1079 -                         $Tuple2(fG, fH)
1085 +                         let fJ = ak(am(fG, aY()), ae)
1086 +                         let fI = ak(am(fJ, bh()), bg())
1087 +                         $Tuple2(fI, fJ)
1080 1088                          }
1081 -             let fG = fF._1
1082 -             let fH = fF._2
1083 -             dF((fB + aZ()), (be() + fH), (bf() + fG), ak(fH, fC), ak(fG, fC))
1089 +             let fI = fH._1
1090 +             let fJ = fH._2
1091 +             dH((fD + aZ()), (be() + fJ), (bf() + fI), ak(fJ, fE), ak(fI, fE))
1084 1092              }
1085 1093      }
1086 1094  
1087 1095  
1088 1096  
1089 - @Callable(ei)
1097 + @Callable(ek)
1090 1098  func v_get (bq) = {
1091 -     let fI = cT(bq)
1092 -     let cF = fI._1
1093 -     let cG = fI._2
1094 -     let cH = fI._3
1095 -     let fJ = fI._4
1096 -     throw((((ai(cG) + ai(cH)) + ai(fJ)) + ai(cS(bq))))
1099 +     let fK = cV(bq, false)
1100 +     let cH = fK._1
1101 +     let cI = fK._2
1102 +     let cJ = fK._3
1103 +     let fL = fK._4
1104 +     throw((((ai(cI) + ai(cJ)) + ai(fL)) + ai(cU(bq))))
1097 1105      }
1098 1106  
1099 1107  
1100 1108  
1101 - @Callable(ei)
1109 + @Callable(ek)
1102 1110  func view_calcRemainMarginWithFundingPayment (bq) = {
1103 -     let fK = bp(bq)
1104 -     let bt = fK._1
1105 -     let cx = fK._2
1106 -     let cP = fK._3
1107 -     let cz = fK._4
1108 -     let fL = cu(bq, ag)
1109 -     let cC = fL._1
1110 -     let cI = fL._2
1111 -     let fM = bT(bt, cx, cz, cI)
1112 -     let cc = fM._1
1113 -     let cd = fM._2
1114 -     let bY = fM._3
1115 -     throw((((ai(cc) + ai(bY)) + ai(cS(bq))) + ai(cI)))
1111 +     let fM = bp(bq)
1112 +     let bt = fM._1
1113 +     let cz = fM._2
1114 +     let cR = fM._3
1115 +     let cB = fM._4
1116 +     let fN = cw(bq, ag)
1117 +     let cE = fN._1
1118 +     let cK = fN._2
1119 +     let fO = bU(bt, cz, cB, cK)
1120 +     let cd = fO._1
1121 +     let ce = fO._2
1122 +     let bZ = fO._3
1123 +     throw(((((ai(cd) + ai(bZ)) + ai(cU(bq))) + ai(cK)) + ai(ce)))
1116 1124      }
1117 1125  
1118 1126  
1119 1127  
1120 - @Callable(ei)
1121 - func forceMoveAsset (bq,ef) = if (if ((addressFromPublicKey(S()) != ei.caller))
1128 + @Callable(ek)
1129 + func forceMoveAsset (bq,eh) = if (if ((addressFromPublicKey(S()) != ek.caller))
1122 1130      then true
1123 -     else (0 > ef))
1131 +     else (0 > eh))
1124 1132      then throw("Invalid forceMoveAsset parameters")
1125 1133      else {
1126 -         let fj = invoke(U(), "unlockNeutrino", [ef, toBase58String(T())], nil)
1127 -         if ((fj == fj))
1128 -             then (ee(addressFromStringValue(bq), ef) ++ eh((aO() - ef)))
1134 +         let fl = invoke(U(), "unlockNeutrino", [eh, toBase58String(T())], nil)
1135 +         if ((fl == fl))
1136 +             then (eg(addressFromStringValue(bq), eh) ++ ej((aO() - eh)))
1129 1137              else throw("Strict value is not equal to itself.")
1130 1138          }
1131 1139  
1132 1140  
1133 - @Verifier(fN)
1134 - func fO () = sigVerify(fN.bodyBytes, fN.proofs[0], S())
1141 + @Verifier(fP)
1142 + func fQ () = sigVerify(fP.bodyBytes, fP.proofs[0], S())
1135 1143  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let a = "k_ora_key"
5 5  
6 6  let b = "k_ora_block_key"
7 7  
8 8  let c = "k_ora"
9 9  
10 10  let d = "k_balance"
11 11  
12 12  let e = "k_positionSize"
13 13  
14 14  let f = "k_positionMargin"
15 15  
16 16  let g = "k_positionOpenNotional"
17 17  
18 18  let h = "k_positionFraction"
19 19  
20 20  let i = "k_initialized"
21 21  
22 22  let j = "k_paused"
23 23  
24 24  let k = "k_fee"
25 25  
26 26  let l = "k_fundingPeriod"
27 27  
28 28  let m = "k_initMarginRatio"
29 29  
30 30  let n = "k_mmr"
31 31  
32 32  let o = "k_liquidationFeeRatio"
33 33  
34 34  let p = "k_spreadLimit"
35 35  
36 36  let q = "k_maxPriceImpact"
37 37  
38 38  let r = "k_lastDataStr"
39 39  
40 40  let s = "k_lastMinuteId"
41 41  
42 42  let t = "k_twapDataLastCumulativePrice"
43 43  
44 44  let u = "k_twapDataLastPrice"
45 45  
46 46  let v = "k_twapDataPreviousMinuteId"
47 47  
48 48  let w = "k_latestLongPremiumFraction"
49 49  
50 50  let x = "k_latestShortPremiumFraction"
51 51  
52 52  let y = "k_nextFundingBlockMinTimestamp"
53 53  
54 54  let z = "k_longFundingRate"
55 55  
56 56  let A = "k_shortFundingRate"
57 57  
58 58  let B = "k_qtAstR"
59 59  
60 60  let C = "k_bsAstR"
61 61  
62 62  let D = "k_totalPositionSize"
63 63  
64 64  let E = "k_totalLongPositionSize"
65 65  
66 66  let F = "k_totalShortPositionSize"
67 67  
68 68  let G = "k_cumulativeNotional"
69 69  
70 70  let H = "k_openInterestNotional"
71 71  
72 72  let I = "k_coordinatorAddress"
73 73  
74 74  let J = "k_insurance_address"
75 75  
76 76  let K = "k_admin_address"
77 77  
78 78  let L = "k_admin_public_key"
79 79  
80 80  let M = "k_quote_asset"
81 81  
82 82  let N = "k_quote_staking"
83 83  
84 84  let O = "k_staking_address"
85 85  
86 86  let P = "k_miner_address"
87 87  
88 88  func Q () = valueOrErrorMessage(addressFromString(getStringValue(this, I)), "Coordinator not set")
89 89  
90 90  
91 91  func R () = addressFromString(getStringValue(Q(), K))
92 92  
93 93  
94 94  func S () = fromBase58String(getStringValue(Q(), L))
95 95  
96 96  
97 97  func T () = fromBase58String(getStringValue(Q(), M))
98 98  
99 99  
100 100  func U () = valueOrErrorMessage(addressFromString(getStringValue(Q(), N)), "Quote asset staking not set")
101 101  
102 102  
103 103  func V () = valueOrErrorMessage(addressFromString(getStringValue(Q(), O)), "Insurance not set")
104 104  
105 105  
106 106  func W () = valueOrErrorMessage(addressFromString(getStringValue(Q(), J)), "Insurance not set")
107 107  
108 108  
109 109  func X () = valueOrErrorMessage(addressFromString(getStringValue(Q(), P)), "Insurance not set")
110 110  
111 111  
112 112  let Y = 1
113 113  
114 114  let Z = 2
115 115  
116 116  let aa = 15
117 117  
118 118  let ab = 15
119 119  
120 120  let ac = 1000
121 121  
122 122  let ad = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
123 123  
124 124  let ae = (86400 * ad)
125 125  
126 126  let af = 100
127 127  
128 128  let ag = 1
129 129  
130 130  let ah = 2
131 131  
132 132  func ai (aj) = (toString(aj) + ",")
133 133  
134 134  
135 135  func ak (aj,al) = fraction(aj, ad, al, HALFEVEN)
136 136  
137 137  
138 138  func am (aj,al) = fraction(aj, al, ad, HALFEVEN)
139 139  
140 140  
141 141  func an (aj) = if ((aj > 0))
142 142      then aj
143 143      else -(aj)
144 144  
145 145  
146 146  func ao (aj,al) = if ((aj >= al))
147 147      then aj
148 148      else al
149 149  
150 150  
151 151  func ap (aq,ar) = ((aq + "_") + ar)
152 152  
153 153  
154 154  func as (at) = {
155 155      func au (av,aw) =     ((av + aw) + ",")
156 156  
157 157      let ax = {
158 158          let ay = at
159 159          let az = size(ay)
160 160          let aA = ""
161 161          func aB (aC,aD) =         if ((aD >= az))
162 162              then aC
163 163              else au(aC, ay[aD])
164 164  
165 165          func aE (aC,aD) =         if ((aD >= az))
166 166              then aC
167 167              else throw("List size exceeds 20")
168 168  
169 169          aE(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aA, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
170 170          }
171 171      let aF = dropRight(ax, 1)
172 172      let aG = if ((take(aF, 1) == ","))
173 173          then drop(aF, 1)
174 174          else aF
175 175      aG
176 176      }
177 177  
178 178  
179 179  func aH (aI) = split(aI, ",")
180 180  
181 181  
182 182  func aJ (at,aK,aL) = if ((size(at) > aK))
183 183      then (removeByIndex(at, 0) :+ aL)
184 184      else (at :+ aL)
185 185  
186 186  
187 187  func aM (aN) = valueOrErrorMessage(getInteger(this, aN), ("no value for " + aN))
188 188  
189 189  
190 190  func aO () = aM(d)
191 191  
192 192  
193 193  func aP () = aM(k)
194 194  
195 195  
196 196  func aQ () = aM(m)
197 197  
198 198  
199 199  func aR () = aM(B)
200 200  
201 201  
202 202  func aS () = aM(C)
203 203  
204 204  
205 205  func aT () = aM(D)
206 206  
207 207  
208 208  func aU () = aM(G)
209 209  
210 210  
211 211  func aV () = aM(H)
212 212  
213 213  
214 214  func aW () = aM(y)
215 215  
216 216  
217 217  func aX () = aM(l)
218 218  
219 219  
220 220  func aY () = (aX() * ad)
221 221  
222 222  
223 223  func aZ () = (aX() * ac)
224 224  
225 225  
226 226  func ba () = aM(n)
227 227  
228 228  
229 229  func bb () = aM(o)
230 230  
231 231  
232 232  func bc () = aM(p)
233 233  
234 234  
235 235  func bd () = aM(q)
236 236  
237 237  
238 238  func be () = aM(w)
239 239  
240 240  
241 241  func bf () = aM(x)
242 242  
243 243  
244 244  func bg () = aM(F)
245 245  
246 246  
247 247  func bh () = aM(E)
248 248  
249 249  
250 250  func bi (bj,bk,bl) = {
251 251      let bm = (bj - bk)
252 252      if (if (bl)
253 253          then (0 > bm)
254 254          else false)
255 255          then throw("Invalid margin")
256 256          else if (if (!(bl))
257 257              then (bm >= 0)
258 258              else false)
259 259              then throw("Invalid margin")
260 260              else true
261 261      }
262 262  
263 263  
264 264  func bn (bo) = if ((bo == 0))
265 265      then throw("Should not be called with _positionSize == 0")
266 266      else if ((bo > 0))
267 267          then be()
268 268          else bf()
269 269  
270 270  
271 271  func bp (bq) = {
272 272      let br = getInteger(this, ap(e, bq))
273 273      let bs = br
274 274      if ($isInstanceOf(bs, "Int"))
275 275          then {
276 276              let bt = bs
277 277              $Tuple4(bt, getIntegerValue(this, ap(f, bq)), getIntegerValue(this, ap(g, bq)), getIntegerValue(this, ap(h, bq)))
278 278              }
279 279          else $Tuple4(0, 0, 0, 0)
280 280      }
281 281  
282 282  
283 283  func bu (bq) = if ((bp(bq)._1 == 0))
284 284      then throw("No open position")
285 285      else true
286 286  
287 287  
288 288  func bv () = valueOrElse(getBoolean(this, i), false)
289 289  
290 290  
291 291  func bw () = valueOrElse(getBoolean(this, j), false)
292 292  
293 293  
294 294  func bx (by,bz,bA) = if (by)
295 295      then {
296 296          let bB = (aS() - bA)
297 297          if ((0 >= bB))
298 298              then throw("Tx lead to base asset reserve <= 0, revert")
299 299              else $Tuple4((aR() + bz), bB, (aT() + bA), (aU() + bz))
300 300          }
301 301      else {
302 302          let bC = (aR() - bz)
303 303          if ((0 >= bC))
304 304              then throw("Tx lead to base quote reserve <= 0, revert")
305 305              else $Tuple4(bC, (aS() + bA), (aT() - bA), (aU() - bz))
306 306          }
307 307  
308 308  
309 309  func bD (by,bz) = {
310 310      let bE = aR()
311 311      let bF = aS()
312 -     let bG = ak(bE, bF)
313 -     let bH = ak(bz, bG)
314 312      let aN = am(bE, bF)
315 -     let bI = if (by)
313 +     let bG = if (by)
316 314          then (bE + bz)
317 315          else (bE - bz)
318 -     let bJ = ak(aN, bI)
319 -     let bK = an((bJ - bF))
320 -     let bL = if (by)
321 -         then bK
322 -         else -(bK)
323 -     let bM = an((ak(bH, bK) - ad))
324 -     let bN = bd()
325 -     if ((bM > bN))
326 -         then throw(((((((((((((("Price impact " + toString(bM)) + " > max price impact ") + toString(bN)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " ideal price buy: ") + toString(bH)) + " real price buy: ") + toString(bK)))
316 +     let bH = ak(aN, bG)
317 +     let bI = an((bH - bF))
318 +     let bJ = if (by)
319 +         then bI
320 +         else -(bI)
321 +     let bK = bx(by, bz, bI)
322 +     let bL = bK._1
323 +     let bM = bK._2
324 +     let bN = bK._3
325 +     let bO = bK._4
326 +     let bP = ak(bE, bF)
327 +     let bQ = ak(bz, bI)
328 +     let bR = an((bP - bQ))
329 +     let bS = (ad - ak(bP, (bP + bR)))
330 +     let bT = bd()
331 +     if ((bS > bT))
332 +         then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " price before: ") + toString(bP)) + " marketPrice: ") + toString(bQ)))
333 +         else $Tuple5(bJ, bL, bM, bN, bO)
334 +     }
335 + 
336 + 
337 + func bU (bV,bW,bX,bY) = {
338 +     let bZ = if ((bV != 0))
339 +         then {
340 +             let ca = bn(bV)
341 +             am((ca - bX), bV)
342 +             }
343 +         else 0
344 +     let cb = ((bY - bZ) + bW)
345 +     let cc = if ((0 > cb))
346 +         then $Tuple2(0, an(cb))
347 +         else $Tuple2(an(cb), 0)
348 +     let cd = cc._1
349 +     let ce = cc._2
350 +     $Tuple3(cd, ce, bZ)
351 +     }
352 + 
353 + 
354 + func cf (by,bA,cg) = {
355 +     let ch = aR()
356 +     let ci = aS()
357 +     let bP = ak(ch, ci)
358 +     if ((bA == 0))
359 +         then throw("Invalid base asset amount")
327 360          else {
328 -             let bO = bx(by, bz, bK)
329 -             let bP = bO._1
330 -             let bQ = bO._2
331 -             let bR = bO._3
332 -             let bS = bO._4
333 -             $Tuple5(bL, bP, bQ, bR, bS)
361 +             let aN = am(ch, ci)
362 +             let cj = if (by)
363 +                 then (ci + bA)
364 +                 else (ci - bA)
365 +             let ck = ak(aN, cj)
366 +             let cl = an((ck - ch))
367 +             let bT = bd()
368 +             let cm = bx(!(by), cl, bA)
369 +             let bL = cm._1
370 +             let bM = cm._2
371 +             let bN = cm._3
372 +             let bO = cm._4
373 +             let bQ = ak(cl, bA)
374 +             let bR = an((bP - bQ))
375 +             let bS = (ad - ak(bP, (bP + bR)))
376 +             if (if ((bS > bT))
377 +                 then cg
378 +                 else false)
379 +                 then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(ch)) + " before base asset: ") + toString(ci)) + " base asset amount to exchange: ") + toString(bA)) + " price before: ") + toString(bP)) + " market price: ") + toString(bQ)))
380 +                 else $Tuple7(cl, bL, bM, bN, bO, (bh() - (if (by)
381 +                     then an(bA)
382 +                     else 0)), (bg() - (if (!(by))
383 +                     then an(bA)
384 +                     else 0)))
334 385              }
335 386      }
336 387  
337 388  
338 - func bT (bU,bV,bW,bX) = {
339 -     let bY = if ((bU != 0))
340 -         then {
341 -             let bZ = bn(bU)
342 -             am((bZ - bW), bU)
343 -             }
344 -         else 0
345 -     let ca = ((bX - bY) + bV)
346 -     let cb = if ((0 > ca))
347 -         then $Tuple2(0, an(ca))
348 -         else $Tuple2(an(ca), 0)
349 -     let cc = cb._1
350 -     let cd = cb._2
351 -     $Tuple3(cc, cd, bY)
389 + func cn () = {
390 +     let co = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
391 +     let cp = getStringValue(this, a)
392 +     let cq = getStringValue(this, b)
393 +     let cr = valueOrErrorMessage(getInteger(co, cp), ((("Can not get oracle price. Oracle: " + toString(co)) + " key: ") + cp))
394 +     cr
352 395      }
353 396  
354 397  
355 - func ce (by,bA) = {
356 -     let cf = aR()
357 -     let cg = aS()
358 -     if ((bA == 0))
359 -         then throw("Invalid base asset amount")
398 + func cs () = {
399 +     let ch = aR()
400 +     let ci = aS()
401 +     ak(ch, ci)
402 +     }
403 + 
404 + 
405 + func ct () = {
406 +     let cu = cn()
407 +     let cv = cs()
408 +     (ak(an((cu - cv)), cu) > bc())
409 +     }
410 + 
411 + 
412 + func cw (bq,cx) = {
413 +     let cy = bp(bq)
414 +     let bt = cy._1
415 +     let cz = cy._2
416 +     let cA = cy._3
417 +     let cB = cy._4
418 +     let cC = an(bt)
419 +     if ((cC == 0))
420 +         then throw("Invalid position size")
360 421          else {
361 -             let aN = am(cf, cg)
362 -             let ch = if (by)
363 -                 then (cg + bA)
364 -                 else (cg - bA)
365 -             let ci = ak(aN, ch)
366 -             let cj = an((ci - cf))
367 -             let ck = bx(!(by), cj, bA)
368 -             let bP = ck._1
369 -             let bQ = ck._2
370 -             let bR = ck._3
371 -             let bS = ck._4
372 -             $Tuple7(cj, bP, bQ, bR, bS, (bh() - (if (by)
373 -                 then an(bA)
374 -                 else 0)), (bg() - (if (!(by))
375 -                 then an(bA)
376 -                 else 0)))
422 +             let cD = (0 > bt)
423 +             let cE = if ((cx == ag))
424 +                 then {
425 +                     let cF = cf(!(cD), cC, false)
426 +                     let cG = cF._1
427 +                     let cH = cF._2
428 +                     let cI = cF._3
429 +                     let cJ = cF._4
430 +                     cG
431 +                     }
432 +                 else am(cC, cn())
433 +             let cK = if (cD)
434 +                 then (cA - cE)
435 +                 else (cE - cA)
436 +             $Tuple2(cE, cK)
377 437              }
378 438      }
379 439  
380 440  
381 - func cl () = {
382 -     let cm = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
383 -     let cn = getStringValue(this, a)
384 -     let co = getStringValue(this, b)
385 -     let cp = valueOrErrorMessage(getInteger(cm, cn), ((("Can not get oracle price. Oracle: " + toString(cm)) + " key: ") + cn))
386 -     cp
441 + func cL (cM,cN,cO) = ak((cM - cN), cO)
442 + 
443 + 
444 + func cP (bq,cx) = {
445 +     let cQ = bp(bq)
446 +     let bt = cQ._1
447 +     let cz = cQ._2
448 +     let cR = cQ._3
449 +     let cB = cQ._4
450 +     let cS = cw(bq, cx)
451 +     let cE = cS._1
452 +     let cK = cS._2
453 +     let cT = bU(bt, cz, cB, cK)
454 +     let cd = cT._1
455 +     let ce = cT._2
456 +     cL(cd, ce, cE)
387 457      }
388 458  
389 459  
390 - func cq () = {
391 -     let cf = aR()
392 -     let cg = aS()
393 -     ak(cf, cg)
460 + func cU (bq) = cP(bq, ag)
461 + 
462 + 
463 + func cV (bq,cg) = {
464 +     let cW = bp(bq)
465 +     let bt = cW._1
466 +     let cz = cW._2
467 +     let cA = cW._3
468 +     let cB = cW._4
469 +     let cX = cw(bq, ag)
470 +     let cH = cX._1
471 +     let cK = cX._2
472 +     let cY = bU(bt, cz, cB, cK)
473 +     let cd = cY._1
474 +     let ce = cY._2
475 +     let cZ = -(bt)
476 +     let da = cK
477 +     let db = -(cd)
478 +     let dc = cf((bt > 0), an(bt), cg)
479 +     let dd = dc._1
480 +     let bG = dc._2
481 +     let bH = dc._3
482 +     let de = dc._4
483 +     let df = dc._5
484 +     let dg = dc._6
485 +     let dh = dc._7
486 +     let di = (aV() - cA)
487 +     $Tuple12(cZ, ce, da, db, bG, bH, de, df, di, dd, dg, dh)
394 488      }
395 489  
396 490  
397 - func cr () = {
398 -     let cs = cl()
399 -     let ct = cq()
400 -     (ak(an((cs - ct)), cs) > bc())
401 -     }
402 - 
403 - 
404 - func cu (bq,cv) = {
405 -     let cw = bp(bq)
406 -     let bt = cw._1
407 -     let cx = cw._2
408 -     let cy = cw._3
409 -     let cz = cw._4
410 -     let cA = an(bt)
411 -     if ((cA == 0))
412 -         then throw("Invalid position size")
413 -         else {
414 -             let cB = (0 > bt)
415 -             let cC = if ((cv == ag))
416 -                 then {
417 -                     let cD = ce(!(cB), cA)
418 -                     let cE = cD._1
419 -                     let cF = cD._2
420 -                     let cG = cD._3
421 -                     let cH = cD._4
422 -                     cE
423 -                     }
424 -                 else am(cA, cl())
425 -             let cI = if (cB)
426 -                 then (cy - cC)
427 -                 else (cC - cy)
428 -             $Tuple2(cC, cI)
429 -             }
430 -     }
431 - 
432 - 
433 - func cJ (cK,cL,cM) = ak((cK - cL), cM)
434 - 
435 - 
436 - func cN (bq,cv) = {
437 -     let cO = bp(bq)
438 -     let bt = cO._1
439 -     let cx = cO._2
440 -     let cP = cO._3
441 -     let cz = cO._4
442 -     let cQ = cu(bq, cv)
443 -     let cC = cQ._1
444 -     let cI = cQ._2
445 -     let cR = bT(bt, cx, cz, cI)
446 -     let cc = cR._1
447 -     let cd = cR._2
448 -     cJ(cc, cd, cC)
449 -     }
450 - 
451 - 
452 - func cS (bq) = cN(bq, ag)
453 - 
454 - 
455 - func cT (bq) = {
456 -     let cU = bp(bq)
457 -     let bt = cU._1
458 -     let cx = cU._2
459 -     let cy = cU._3
460 -     let cz = cU._4
461 -     let cV = cu(bq, ag)
462 -     let cF = cV._1
463 -     let cI = cV._2
464 -     let cW = bT(bt, cx, cz, cI)
465 -     let cc = cW._1
466 -     let cd = cW._2
467 -     let cX = -(bt)
468 -     let cY = cI
469 -     let cZ = -(cc)
470 -     let da = ce((bt > 0), an(bt))
471 -     let db = da._1
472 -     let bI = da._2
473 -     let bJ = da._3
474 -     let dc = da._4
475 -     let dd = da._5
476 -     let de = da._6
477 -     let df = da._7
478 -     let dg = (aV() - cy)
479 -     $Tuple12(cX, cd, cY, cZ, bI, bJ, dc, dd, dg, db, de, df)
480 -     }
481 - 
482 - 
483 - func dh () = {
484 -     let di = ((lastBlock.timestamp / 1000) / 60)
485 -     let dj = (di - aa)
486 -     let dk = valueOrElse(getString(this, r), "")
487 -     let dl = split(dk, ",")
488 -     func dm (av,dn) =     if ((dj >= parseIntValue(dn)))
489 -         then (av :+ parseIntValue(dn))
491 + func dj () = {
492 +     let dk = ((lastBlock.timestamp / 1000) / 60)
493 +     let dl = (dk - aa)
494 +     let dm = valueOrElse(getString(this, r), "")
495 +     let dn = split(dm, ",")
496 +     func do (av,dp) =     if ((dl >= parseIntValue(dp)))
497 +         then (av :+ parseIntValue(dp))
490 498          else av
491 499  
492 -     let do = {
493 -         let ay = dl
500 +     let dq = {
501 +         let ay = dn
494 502          let az = size(ay)
495 503          let aA = nil
496 504          func aB (aC,aD) =         if ((aD >= az))
497 505              then aC
498 -             else dm(aC, ay[aD])
506 +             else do(aC, ay[aD])
499 507  
500 508          func aE (aC,aD) =         if ((aD >= az))
501 509              then aC
502 510              else throw("List size exceeds 20")
503 511  
504 512          aE(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aA, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
505 513          }
506 -     let dp = if ((size(do) > 0))
507 -         then max(do)
508 -         else parseIntValue(dl[0])
509 -     let dq = valueOrElse(getInteger(this, s), 0)
510 -     let dr = valueOrElse(getInteger(this, ((t + "_") + toString(dq))), 0)
511 -     let ds = valueOrElse(getInteger(this, ((u + "_") + toString(dq))), 0)
512 -     let dt = (dr + ((di - dq) * ds))
513 -     let du = valueOrElse(getInteger(this, ((t + "_") + toString(dp))), 0)
514 -     let dv = valueOrElse(getInteger(this, ((u + "_") + toString(dp))), 0)
515 -     let dw = (du + ((dj - dp) * dv))
516 -     ((dt - dw) / aa)
514 +     let dr = if ((size(dq) > 0))
515 +         then max(dq)
516 +         else parseIntValue(dn[0])
517 +     let ds = valueOrElse(getInteger(this, s), 0)
518 +     let dt = valueOrElse(getInteger(this, ((t + "_") + toString(ds))), 0)
519 +     let du = valueOrElse(getInteger(this, ((u + "_") + toString(ds))), 0)
520 +     let dv = (dt + ((dk - ds) * du))
521 +     let dw = valueOrElse(getInteger(this, ((t + "_") + toString(dr))), 0)
522 +     let dx = valueOrElse(getInteger(this, ((u + "_") + toString(dr))), 0)
523 +     let dy = (dw + ((dl - dr) * dx))
524 +     ((dv - dy) / aa)
517 525      }
518 526  
519 527  
520 - func dx (dy,dz,dA,dB,dC,dD,dE) = [IntegerEntry(m, dy), IntegerEntry(n, dz), IntegerEntry(o, dA), IntegerEntry(l, dB), IntegerEntry(k, dC), IntegerEntry(p, dD), IntegerEntry(q, dE)]
528 + func dz (dA,dB,dC,dD,dE,dF,dG) = [IntegerEntry(m, dA), IntegerEntry(n, dB), IntegerEntry(o, dC), IntegerEntry(l, dD), IntegerEntry(k, dE), IntegerEntry(p, dF), IntegerEntry(q, dG)]
521 529  
522 530  
523 - func dF (dG,dH,dI,dJ,dK) = [IntegerEntry(y, dG), IntegerEntry(w, dH), IntegerEntry(x, dI), IntegerEntry(z, dJ), IntegerEntry(A, dK)]
531 + func dH (dI,dJ,dK,dL,dM) = [IntegerEntry(y, dI), IntegerEntry(w, dJ), IntegerEntry(x, dK), IntegerEntry(z, dL), IntegerEntry(A, dM)]
524 532  
525 533  
526 - func dL (ar,dM,dN,dO,bZ) = [IntegerEntry(ap(e, ar), dM), IntegerEntry(ap(f, ar), dN), IntegerEntry(ap(g, ar), dO), IntegerEntry(ap(h, ar), bZ)]
534 + func dN (ar,dO,dP,dQ,ca) = [IntegerEntry(ap(e, ar), dO), IntegerEntry(ap(f, ar), dP), IntegerEntry(ap(g, ar), dQ), IntegerEntry(ap(h, ar), ca)]
527 535  
528 536  
529 - func dP (dQ) = {
530 -     let di = ((lastBlock.timestamp / 1000) / 60)
531 -     let dR = valueOrElse(getInteger(this, s), 0)
532 -     if ((dR > di))
537 + func dR (dS) = {
538 +     let dk = ((lastBlock.timestamp / 1000) / 60)
539 +     let dT = valueOrElse(getInteger(this, s), 0)
540 +     if ((dT > dk))
533 541          then throw("TWAP out-of-order")
534 542          else {
535 -             let dq = if ((dR == 0))
536 -                 then di
537 -                 else dR
538 -             if ((di > dR))
543 +             let ds = if ((dT == 0))
544 +                 then dk
545 +                 else dT
546 +             if ((dk > dT))
539 547                  then {
540 -                     let dS = valueOrElse(getInteger(this, ((t + "_") + toString(dR))), 0)
541 -                     let dT = valueOrElse(getInteger(this, ((u + "_") + toString(dR))), dQ)
542 -                     let dU = (dS + ((di - dq) * dT))
543 -                     let dl = aJ(aH(valueOrElse(getString(this, r), "")), aa, toString(di))
544 - [IntegerEntry(ap(t, toString(di)), dU), IntegerEntry(ap(u, toString(di)), dQ), IntegerEntry(ap(v, toString(di)), dR), IntegerEntry(s, di), StringEntry(r, as(dl))]
548 +                     let dU = valueOrElse(getInteger(this, ((t + "_") + toString(dT))), 0)
549 +                     let dV = valueOrElse(getInteger(this, ((u + "_") + toString(dT))), dS)
550 +                     let dW = (dU + ((dk - ds) * dV))
551 +                     let dn = aJ(aH(valueOrElse(getString(this, r), "")), aa, toString(dk))
552 + [IntegerEntry(ap(t, toString(dk)), dW), IntegerEntry(ap(u, toString(dk)), dS), IntegerEntry(ap(v, toString(dk)), dT), IntegerEntry(s, dk), StringEntry(r, as(dn))]
545 553                      }
546 554                  else {
547 -                     let dV = valueOrElse(getInteger(this, ap(v, toString(di))), 0)
548 -                     let dS = valueOrElse(getInteger(this, ap(t, toString(dV))), 0)
549 -                     let dT = valueOrElse(getInteger(this, ap(u, toString(dV))), dQ)
550 -                     let dU = (dS + ((di - dV) * dT))
551 - [IntegerEntry(ap(t, toString(di)), dU), IntegerEntry(ap(u, toString(di)), dQ)]
555 +                     let dX = valueOrElse(getInteger(this, ap(v, toString(dk))), 0)
556 +                     let dU = valueOrElse(getInteger(this, ap(t, toString(dX))), 0)
557 +                     let dV = valueOrElse(getInteger(this, ap(u, toString(dX))), dS)
558 +                     let dW = (dU + ((dk - dX) * dV))
559 + [IntegerEntry(ap(t, toString(dk)), dW), IntegerEntry(ap(u, toString(dk)), dS)]
552 560                      }
553 561              }
554 562      }
555 563  
556 564  
557 - func dW (bE,bF) = [IntegerEntry(B, bE), IntegerEntry(C, bF)]
565 + func dY (bE,bF) = [IntegerEntry(B, bE), IntegerEntry(C, bF)]
558 566  
559 567  
560 - func dX (bE,bF,dY,dZ,ea,eb,ec) = if (((eb - ec) != dY))
561 -     then throw(((((("Invalid AMM state data: " + toString(eb)) + " +  ") + toString(ec)) + " != ") + toString(dY)))
562 -     else ((dW(bE, bF) ++ [IntegerEntry(D, dY), IntegerEntry(G, dZ), IntegerEntry(H, ea), IntegerEntry(E, eb), IntegerEntry(F, ec)]) ++ dP(ak(bE, bF)))
568 + func dZ (bE,bF,ea,eb,ec,ed,ee) = if (((ed - ee) != ea))
569 +     then throw(((((("Invalid AMM state data: " + toString(ed)) + " +  ") + toString(ee)) + " != ") + toString(ea)))
570 +     else ((dY(bE, bF) ++ [IntegerEntry(D, ea), IntegerEntry(G, eb), IntegerEntry(H, ec), IntegerEntry(E, ed), IntegerEntry(F, ee)]) ++ dR(ak(bE, bF)))
563 571  
564 572  
565 - func ed (ar) = [DeleteEntry(ap(e, ar)), DeleteEntry(ap(f, ar)), DeleteEntry(ap(g, ar)), DeleteEntry(ap(h, ar))]
573 + func ef (ar) = [DeleteEntry(ap(e, ar)), DeleteEntry(ap(f, ar)), DeleteEntry(ap(g, ar)), DeleteEntry(ap(h, ar))]
566 574  
567 575  
568 - func ee (ar,ef) = {
569 -     let eg = assetBalance(this, T())
570 -     if ((ef > eg))
571 -         then throw(((("Unable to withdraw " + toString(ef)) + " from contract balance ") + toString(eg)))
572 -         else [ScriptTransfer(ar, ef, T())]
576 + func eg (ar,eh) = {
577 +     let ei = assetBalance(this, T())
578 +     if ((eh > ei))
579 +         then throw(((("Unable to withdraw " + toString(eh)) + " from contract balance ") + toString(ei)))
580 +         else [ScriptTransfer(ar, eh, T())]
573 581      }
574 582  
575 583  
576 - func eh (ei) = if ((0 > ei))
584 + func ej (ek) = if ((0 > ek))
577 585      then throw("Balance")
578 -     else [IntegerEntry(d, ei)]
586 +     else [IntegerEntry(d, ek)]
579 587  
580 588  
581 - func ej (ei) = [ScriptTransfer(V(), ei, T())]
589 + func el (ek) = [ScriptTransfer(V(), ek, T())]
582 590  
583 591  
584 - @Callable(ei)
585 - func pause () = if ((ei.caller != R()))
592 + @Callable(ek)
593 + func pause () = if ((ek.caller != R()))
586 594      then throw("Invalid togglePause params")
587 595      else [BooleanEntry(j, true)]
588 596  
589 597  
590 598  
591 - @Callable(ei)
592 - func unpause () = if ((ei.caller != R()))
599 + @Callable(ek)
600 + func unpause () = if ((ek.caller != R()))
593 601      then throw("Invalid togglePause params")
594 602      else [BooleanEntry(j, false)]
595 603  
596 604  
597 605  
598 - @Callable(ei)
599 - func addLiquidity (bz) = if (if ((ei.caller != R()))
606 + @Callable(ek)
607 + func addLiquidity (bz) = if (if ((ek.caller != R()))
600 608      then true
601 609      else (0 >= bz))
602 610      then throw("Invalid addLiquidity params")
603 611      else {
604 612          let bE = aR()
605 613          let bF = aS()
606 -         let dQ = ak(bE, bF)
607 -         let ek = ak(bz, dQ)
608 -         let el = (bE + bz)
609 -         let em = (bF + ek)
610 -         dW(el, em)
614 +         let dS = ak(bE, bF)
615 +         let em = ak(bz, dS)
616 +         let en = (bE + bz)
617 +         let eo = (bF + em)
618 +         dY(en, eo)
611 619          }
612 620  
613 621  
614 622  
615 - @Callable(ei)
616 - func removeLiquidity (bz) = if (if ((ei.caller != R()))
623 + @Callable(ek)
624 + func removeLiquidity (bz) = if (if ((ek.caller != R()))
617 625      then true
618 626      else (0 >= bz))
619 627      then throw("Invalid removeLiquidity params")
620 628      else {
621 629          let bE = aR()
622 630          let bF = aS()
623 -         let dQ = ak(bE, bF)
624 -         let en = ak(bz, dQ)
625 -         let el = (bE - bz)
626 -         let em = (bF - en)
627 -         dW(el, em)
631 +         let dS = ak(bE, bF)
632 +         let ep = ak(bz, dS)
633 +         let en = (bE - bz)
634 +         let eo = (bF - ep)
635 +         dY(en, eo)
628 636          }
629 637  
630 638  
631 639  
632 - @Callable(ei)
633 - func changeSettings (dy,dz,dA,dB,dC,dD,dE) = if ((ei.caller != R()))
640 + @Callable(ek)
641 + func changeSettings (dA,dB,dC,dD,dE,dF,dG) = if ((ek.caller != R()))
634 642      then throw("Invalid changeSettings params")
635 -     else dx(dy, dz, dA, dB, dC, dD, dE)
643 +     else dz(dA, dB, dC, dD, dE, dF, dG)
636 644  
637 645  
638 646  
639 - @Callable(ei)
640 - func initialize (bE,bF,dB,dy,dz,dA,dC,eo,ep,eq,dD,dE) = if (if (if (if (if (if (if (if (if (if ((0 >= bE))
647 + @Callable(ek)
648 + func initialize (bE,bF,dD,dA,dB,dC,dE,eq,er,es,dF,dG) = if (if (if (if (if (if (if (if (if (if ((0 >= bE))
641 649      then true
642 650      else (0 >= bF))
643 651      then true
644 -     else (0 >= dB))
645 -     then true
646 -     else (0 >= dy))
647 -     then true
648 -     else (0 >= dz))
652 +     else (0 >= dD))
649 653      then true
650 654      else (0 >= dA))
651 655      then true
656 +     else (0 >= dB))
657 +     then true
652 658      else (0 >= dC))
653 -     then true
654 -     else (0 >= dD))
655 659      then true
656 660      else (0 >= dE))
657 661      then true
662 +     else (0 >= dF))
663 +     then true
664 +     else (0 >= dG))
665 +     then true
658 666      else bv())
659 667      then throw("Invalid initialize parameters")
660 -     else ((((dX(bE, bF, 0, 0, 0, 0, 0) ++ dx(dy, dz, dA, dB, dC, dD, dE)) ++ dF((lastBlock.timestamp + dB), 0, 0, 0, 0)) ++ eh(0)) ++ [BooleanEntry(i, true), StringEntry(c, eo), StringEntry(a, ep), StringEntry(I, eq)])
668 +     else ((((dZ(bE, bF, 0, 0, 0, 0, 0) ++ dz(dA, dB, dC, dD, dE, dF, dG)) ++ dH((lastBlock.timestamp + dD), 0, 0, 0, 0)) ++ ej(0)) ++ [BooleanEntry(i, true), StringEntry(c, eq), StringEntry(a, er), StringEntry(I, es)])
661 669  
662 670  
663 671  
664 - @Callable(ei)
665 - func decreasePosition (ef,er,es) = if (if (if (if (if ((0 >= ef))
672 + @Callable(ek)
673 + func decreasePosition (eh,et,eu) = if (if (if (if (if ((0 >= eh))
666 674      then true
667 675      else !(bv()))
668 676      then true
669 -     else !(bi(ak(ad, er), aQ(), true)))
677 +     else !(bi(ak(ad, et), aQ(), true)))
670 678      then true
671 -     else !(bu(toString(ei.caller))))
679 +     else !(bu(toString(ek.caller))))
672 680      then true
673 681      else bw())
674 682      then throw("Invalid decreasePosition parameters")
675 683      else {
676 -         let et = bp(toString(ei.caller))
677 -         let eu = et._1
678 -         let ev = et._2
679 -         let ew = et._3
680 -         let ex = et._4
681 -         let ey = if ((eu > 0))
684 +         let ev = bp(toString(ek.caller))
685 +         let ew = ev._1
686 +         let ex = ev._2
687 +         let ey = ev._3
688 +         let ez = ev._4
689 +         let eA = if ((ew > 0))
682 690              then Z
683 691              else Y
684 -         let ez = (ey == Y)
685 -         let eA = am(ef, er)
686 -         let eB = cu(toString(ei.caller), ag)
687 -         let eC = eB._1
688 -         let cI = eB._2
689 -         let eD = if ((eC > eA))
692 +         let eB = (eA == Y)
693 +         let eC = am(eh, et)
694 +         let eD = cw(toString(ek.caller), ag)
695 +         let eE = eD._1
696 +         let cK = eD._2
697 +         let eF = if ((eE > eC))
690 698              then {
691 -                 let eE = bD(ez, eA)
692 -                 let cX = eE._1
693 -                 let bI = eE._2
694 -                 let bJ = eE._3
695 -                 let dc = eE._4
696 -                 let dd = eE._5
697 -                 let eF = an(cX)
698 -                 if (if ((es != 0))
699 -                     then (es > eF)
699 +                 let eG = bD(eB, eC)
700 +                 let cZ = eG._1
701 +                 let bG = eG._2
702 +                 let bH = eG._3
703 +                 let de = eG._4
704 +                 let df = eG._5
705 +                 let eH = an(cZ)
706 +                 if (if ((eu != 0))
707 +                     then (eu > eH)
700 708                      else false)
701 -                     then throw(((("Too little base asset exchanged, got " + toString(eF)) + " expected ") + toString(es)))
709 +                     then throw(((("Too little base asset exchanged, got " + toString(eH)) + " expected ") + toString(eu)))
702 710                      else {
703 -                         let cY = ak(am(cI, eF), an(eu))
704 -                         let eG = bT(eu, ev, ex, cY)
705 -                         let cc = eG._1
706 -                         let cd = eG._2
707 -                         let bY = eG._3
708 -                         let db = eA
709 -                         let eH = (cI - cY)
710 -                         let eI = if ((eu > 0))
711 -                             then ((eC - db) - eH)
712 -                             else ((eH + eC) - db)
713 -                         let eJ = (eu + cX)
714 -                         $Tuple11(eJ, cc, an(eI), bn(eJ), bJ, bI, dc, dd, (aV() - eA), (bh() - (if ((eJ > 0))
715 -                             then an(cX)
716 -                             else 0)), (bg() - (if ((0 > eJ))
717 -                             then an(cX)
711 +                         let da = ak(am(cK, eH), an(ew))
712 +                         let eI = bU(ew, ex, ez, da)
713 +                         let cd = eI._1
714 +                         let ce = eI._2
715 +                         let bZ = eI._3
716 +                         let dd = eC
717 +                         let eJ = (cK - da)
718 +                         let eK = if ((ew > 0))
719 +                             then ((eE - dd) - eJ)
720 +                             else ((eJ + eE) - dd)
721 +                         let eL = (ew + cZ)
722 +                         $Tuple11(eL, cd, an(eK), bn(eL), bH, bG, de, df, (aV() - eC), (bh() - (if ((eL > 0))
723 +                             then an(cZ)
724 +                             else 0)), (bg() - (if ((0 > eL))
725 +                             then an(cZ)
718 726                              else 0)))
719 727                          }
720 728                  }
721 729              else throw("Close position first")
722 -         let eJ = eD._1
723 -         let eK = eD._2
724 -         let eL = eD._3
725 -         let eM = eD._4
726 -         let bJ = eD._5
727 -         let bI = eD._6
728 -         let dc = eD._7
729 -         let dd = eD._8
730 -         let dg = eD._9
731 -         let de = eD._10
732 -         let df = eD._11
733 -         let eN = invoke(X(), "notifyNotional", [toString(ei.caller), eL], nil)
734 -         if ((eN == eN))
735 -             then (dL(toString(ei.caller), eJ, eK, eL, eM) ++ dX(bI, bJ, dc, dd, dg, de, df))
730 +         let eL = eF._1
731 +         let eM = eF._2
732 +         let eN = eF._3
733 +         let eO = eF._4
734 +         let bH = eF._5
735 +         let bG = eF._6
736 +         let de = eF._7
737 +         let df = eF._8
738 +         let di = eF._9
739 +         let dg = eF._10
740 +         let dh = eF._11
741 +         let eP = invoke(X(), "notifyNotional", [toString(ek.caller), eN], nil)
742 +         if ((eP == eP))
743 +             then (dN(toString(ek.caller), eL, eM, eN, eO) ++ dZ(bG, bH, de, df, di, dg, dh))
736 744              else throw("Strict value is not equal to itself.")
737 745          }
738 746  
739 747  
740 748  
741 - @Callable(ei)
742 - func increasePosition (ey,er,es) = {
743 -     let eO = ei.payments[0].amount
744 -     if (if (if (if (if (if (if ((ey != Y))
745 -         then (ey != Z)
749 + @Callable(ek)
750 + func increasePosition (eA,et,eu) = {
751 +     let eQ = ek.payments[0].amount
752 +     if (if (if (if (if (if (if ((eA != Y))
753 +         then (eA != Z)
746 754          else false)
747 755          then true
748 -         else (0 >= eO))
756 +         else (0 >= eQ))
749 757          then true
750 758          else !(bv()))
751 759          then true
752 -         else (ei.payments[0].assetId != T()))
760 +         else (ek.payments[0].assetId != T()))
753 761          then true
754 -         else !(bi(ak(ad, er), aQ(), true)))
762 +         else !(bi(ak(ad, et), aQ(), true)))
755 763          then true
756 764          else bw())
757 765          then throw("Invalid increasePosition parameters")
758 766          else {
759 -             let eP = am(eO, aP())
760 -             let ef = (eO - eP)
761 -             let eQ = bp(toString(ei.caller))
762 -             let eu = eQ._1
763 -             let ev = eQ._2
764 -             let ew = eQ._3
765 -             let ex = eQ._4
766 -             let eR = (eu == 0)
767 -             let eS = if ((eu > 0))
768 -                 then (ey == Y)
769 -                 else (ey == Z)
770 -             let eT = if (!(eR))
771 -                 then eS
767 +             let eR = am(eQ, aP())
768 +             let eh = (eQ - eR)
769 +             let eS = bp(toString(ek.caller))
770 +             let ew = eS._1
771 +             let ex = eS._2
772 +             let ey = eS._3
773 +             let ez = eS._4
774 +             let eT = (ew == 0)
775 +             let eU = if ((ew > 0))
776 +                 then (eA == Y)
777 +                 else (eA == Z)
778 +             let eV = if (!(eT))
779 +                 then eU
772 780                  else false
773 -             let ez = (ey == Y)
774 -             let eU = if (if (eR)
781 +             let eB = (eA == Y)
782 +             let eW = if (if (eT)
775 783                  then true
776 -                 else eT)
784 +                 else eV)
777 785                  then {
778 -                     let eA = am(ef, er)
779 -                     let eV = bD(ez, eA)
780 -                     let bL = eV._1
781 -                     let bI = eV._2
782 -                     let bJ = eV._3
783 -                     let dc = eV._4
784 -                     let dd = eV._5
785 -                     if (if ((es != 0))
786 -                         then (es > an(bL))
786 +                     let eC = am(eh, et)
787 +                     let eX = bD(eB, eC)
788 +                     let bJ = eX._1
789 +                     let bG = eX._2
790 +                     let bH = eX._3
791 +                     let de = eX._4
792 +                     let df = eX._5
793 +                     if (if ((eu != 0))
794 +                         then (eu > an(bJ))
787 795                          else false)
788 -                         then throw(((("Limit error: " + toString(an(bL))) + " < ") + toString(es)))
796 +                         then throw(((("Limit error: " + toString(an(bJ))) + " < ") + toString(eu)))
789 797                          else {
790 -                             let eJ = (eu + bL)
791 -                             let eW = ak(eA, er)
792 -                             let eX = bT(eu, ev, ex, eW)
793 -                             let cc = eX._1
794 -                             let cF = eX._2
795 -                             let cG = eX._3
796 -                             $Tuple11(eJ, cc, (ew + eA), bn(eJ), bJ, bI, dc, dd, (aV() + eA), (bh() + (if ((eJ > 0))
797 -                                 then an(bL)
798 -                                 else 0)), (bg() + (if ((0 > eJ))
799 -                                 then an(bL)
798 +                             let eL = (ew + bJ)
799 +                             let eY = ak(eC, et)
800 +                             let eZ = bU(ew, ex, ez, eY)
801 +                             let cd = eZ._1
802 +                             let cH = eZ._2
803 +                             let cI = eZ._3
804 +                             $Tuple11(eL, cd, (ey + eC), bn(eL), bH, bG, de, df, (aV() + eC), (bh() + (if ((eL > 0))
805 +                                 then an(bJ)
806 +                                 else 0)), (bg() + (if ((0 > eL))
807 +                                 then an(bJ)
800 808                                  else 0)))
801 809                              }
802 810                      }
803 811                  else {
804 -                     let eA = am(ef, er)
805 -                     let eY = cu(toString(ei.caller), ag)
806 -                     let eC = eY._1
807 -                     let cI = eY._2
808 -                     if ((eC > eA))
812 +                     let eC = am(eh, et)
813 +                     let fa = cw(toString(ek.caller), ag)
814 +                     let eE = fa._1
815 +                     let cK = fa._2
816 +                     if ((eE > eC))
809 817                          then throw("Use decreasePosition to decrease position size")
810 818                          else throw("Close position first")
811 819                      }
812 -             let eJ = eU._1
813 -             let eK = eU._2
814 -             let eL = eU._3
815 -             let eM = eU._4
816 -             let bJ = eU._5
817 -             let bI = eU._6
818 -             let dc = eU._7
819 -             let dd = eU._8
820 -             let dg = eU._9
821 -             let de = eU._10
822 -             let df = eU._11
823 -             let eZ = (eP / 2)
824 -             let fa = (eP - eZ)
825 -             let fb = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), ef)])
826 -             if ((fb == fb))
820 +             let eL = eW._1
821 +             let eM = eW._2
822 +             let eN = eW._3
823 +             let eO = eW._4
824 +             let bH = eW._5
825 +             let bG = eW._6
826 +             let de = eW._7
827 +             let df = eW._8
828 +             let di = eW._9
829 +             let dg = eW._10
830 +             let dh = eW._11
831 +             let fb = (eR / 2)
832 +             let fc = (eR - fb)
833 +             let fd = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), eh)])
834 +             if ((fd == fd))
827 835                  then {
828 -                     let fc = invoke(W(), "deposit", nil, [AttachedPayment(T(), fa)])
829 -                     if ((fc == fc))
836 +                     let fe = invoke(W(), "deposit", nil, [AttachedPayment(T(), fc)])
837 +                     if ((fe == fe))
830 838                          then {
831 -                             let fd = invoke(X(), "notifyFees", [toString(ei.caller), eP], nil)
832 -                             if ((fd == fd))
839 +                             let ff = invoke(X(), "notifyFees", [toString(ek.caller), eR], nil)
840 +                             if ((ff == ff))
833 841                                  then {
834 -                                     let eN = invoke(X(), "notifyNotional", [toString(ei.caller), eL], nil)
835 -                                     if ((eN == eN))
836 -                                         then (((dL(toString(ei.caller), eJ, eK, eL, eM) ++ dX(bI, bJ, dc, dd, dg, de, df)) ++ ej(eZ)) ++ eh((aO() + ef)))
842 +                                     let eP = invoke(X(), "notifyNotional", [toString(ek.caller), eN], nil)
843 +                                     if ((eP == eP))
844 +                                         then (((dN(toString(ek.caller), eL, eM, eN, eO) ++ dZ(bG, bH, de, df, di, dg, dh)) ++ el(fb)) ++ ej((aO() + eh)))
837 845                                          else throw("Strict value is not equal to itself.")
838 846                                      }
839 847                                  else throw("Strict value is not equal to itself.")
840 848                              }
841 849                          else throw("Strict value is not equal to itself.")
842 850                      }
843 851                  else throw("Strict value is not equal to itself.")
844 852              }
845 853      }
846 854  
847 855  
848 856  
849 - @Callable(ei)
857 + @Callable(ek)
850 858  func addMargin () = {
851 -     let eO = ei.payments[0].amount
852 -     if (if (if (if ((ei.payments[0].assetId != T()))
859 +     let eQ = ek.payments[0].amount
860 +     if (if (if (if ((ek.payments[0].assetId != T()))
853 861          then true
854 -         else !(bu(toString(ei.caller))))
862 +         else !(bu(toString(ek.caller))))
855 863          then true
856 864          else !(bv()))
857 865          then true
858 866          else bw())
859 867          then throw("Invalid addMargin parameters")
860 868          else {
861 -             let eP = am(eO, aP())
862 -             let ef = (eO - eP)
863 -             let fe = bp(toString(ei.caller))
864 -             let eu = fe._1
865 -             let ev = fe._2
866 -             let ew = fe._3
867 -             let ex = fe._4
868 -             let eZ = (eP / 2)
869 -             let fa = (eP - eZ)
870 -             let fb = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), ef)])
871 -             if ((fb == fb))
869 +             let eR = am(eQ, aP())
870 +             let eh = (eQ - eR)
871 +             let fg = bp(toString(ek.caller))
872 +             let ew = fg._1
873 +             let ex = fg._2
874 +             let ey = fg._3
875 +             let ez = fg._4
876 +             let fb = (eR / 2)
877 +             let fc = (eR - fb)
878 +             let fd = invoke(U(), "lockNeutrinoSP", [toString(V()), af], [AttachedPayment(T(), eh)])
879 +             if ((fd == fd))
872 880                  then {
873 -                     let fc = invoke(W(), "deposit", nil, [AttachedPayment(T(), fa)])
874 -                     if ((fc == fc))
881 +                     let fe = invoke(W(), "deposit", nil, [AttachedPayment(T(), fc)])
882 +                     if ((fe == fe))
875 883                          then {
876 -                             let fd = invoke(X(), "notifyFees", [toString(ei.caller), eP], nil)
877 -                             if ((fd == fd))
878 -                                 then ((dL(toString(ei.caller), eu, (ev + ef), ew, ex) ++ ej(eZ)) ++ eh((aO() + ef)))
884 +                             let ff = invoke(X(), "notifyFees", [toString(ek.caller), eR], nil)
885 +                             if ((ff == ff))
886 +                                 then ((dN(toString(ek.caller), ew, (ex + eh), ey, ez) ++ el(fb)) ++ ej((aO() + eh)))
879 887                                  else throw("Strict value is not equal to itself.")
880 888                              }
881 889                          else throw("Strict value is not equal to itself.")
882 890                      }
883 891                  else throw("Strict value is not equal to itself.")
884 892              }
885 893      }
886 894  
887 895  
888 896  
889 - @Callable(ei)
890 - func removeMargin (ef) = if (if (if (if ((0 >= ef))
897 + @Callable(ek)
898 + func removeMargin (eh) = if (if (if (if ((0 >= eh))
891 899      then true
892 -     else !(bu(toString(ei.caller))))
900 +     else !(bu(toString(ek.caller))))
893 901      then true
894 902      else !(bv()))
895 903      then true
896 904      else bw())
897 905      then throw("Invalid removeMargin parameters")
898 906      else {
899 -         let ff = bp(toString(ei.caller))
900 -         let eu = ff._1
901 -         let ev = ff._2
902 -         let ew = ff._3
903 -         let ex = ff._4
904 -         let fg = -(ef)
905 -         let fh = bT(eu, ev, ex, fg)
906 -         let cc = fh._1
907 -         let cd = fh._2
908 -         if ((cd != 0))
907 +         let fh = bp(toString(ek.caller))
908 +         let ew = fh._1
909 +         let ex = fh._2
910 +         let ey = fh._3
911 +         let ez = fh._4
912 +         let fi = -(eh)
913 +         let fj = bU(ew, ex, ez, fi)
914 +         let cd = fj._1
915 +         let ce = fj._2
916 +         if ((ce != 0))
909 917              then throw("Invalid removed margin amount")
910 918              else {
911 -                 let fi = cJ(cc, cd, ew)
912 -                 if (!(bi(fi, aQ(), true)))
913 -                     then throw(((("Too much margin removed: " + toString(fi)) + " < ") + toString(aQ())))
919 +                 let fk = cL(cd, ce, ey)
920 +                 if (!(bi(fk, aQ(), true)))
921 +                     then throw(((("Too much margin removed: " + toString(fk)) + " < ") + toString(aQ())))
914 922                      else {
915 -                         let fj = invoke(U(), "unlockNeutrino", [ef, toBase58String(T())], nil)
916 -                         if ((fj == fj))
917 -                             then ((dL(toString(ei.caller), eu, cc, ew, bn(eu)) ++ ee(ei.caller, ef)) ++ eh((aO() - ef)))
923 +                         let fl = invoke(U(), "unlockNeutrino", [eh, toBase58String(T())], nil)
924 +                         if ((fl == fl))
925 +                             then ((dN(toString(ek.caller), ew, cd, ey, bn(ew)) ++ eg(ek.caller, eh)) ++ ej((aO() - eh)))
918 926                              else throw("Strict value is not equal to itself.")
919 927                          }
920 928                  }
921 929          }
922 930  
923 931  
924 932  
925 - @Callable(ei)
926 - func closePosition () = if (if (if (!(bu(toString(ei.caller))))
933 + @Callable(ek)
934 + func closePosition () = if (if (if (!(bu(toString(ek.caller))))
927 935      then true
928 936      else !(bv()))
929 937      then true
930 938      else bw())
931 939      then throw("Invalid closePosition parameters")
932 940      else {
933 -         let fk = cT(toString(ei.caller))
934 -         let cF = fk._1
935 -         let fl = fk._2
936 -         let cY = fk._3
937 -         let cZ = fk._4
938 -         let bI = fk._5
939 -         let bJ = fk._6
940 -         let dc = fk._7
941 -         let dd = fk._8
942 -         let dg = fk._9
943 -         let cG = fk._10
944 -         let de = fk._11
945 -         let df = fk._12
946 -         if ((fl > 0))
941 +         let fm = cV(toString(ek.caller), true)
942 +         let cH = fm._1
943 +         let fn = fm._2
944 +         let da = fm._3
945 +         let db = fm._4
946 +         let bG = fm._5
947 +         let bH = fm._6
948 +         let de = fm._7
949 +         let df = fm._8
950 +         let di = fm._9
951 +         let cI = fm._10
952 +         let dg = fm._11
953 +         let dh = fm._12
954 +         if ((fn > 0))
947 955              then throw("Unable to close position with bad debt")
948 956              else {
949 -                 let fm = an(cZ)
950 -                 let fn = (aO() - fm)
951 -                 let fo = if ((0 > fn))
952 -                     then $Tuple2(0, an(fn))
953 -                     else $Tuple2(fn, 0)
954 -                 let fp = fo._1
955 -                 let fq = fo._2
956 -                 let fr = if ((fq > 0))
957 +                 let fo = an(db)
958 +                 let fp = (aO() - fo)
959 +                 let fq = if ((0 > fp))
960 +                     then $Tuple2(0, an(fp))
961 +                     else $Tuple2(fp, 0)
962 +                 let fr = fq._1
963 +                 let fs = fq._2
964 +                 let ft = if ((fs > 0))
957 965                      then {
958 -                         let fs = invoke(W(), "withdraw", [fq], nil)
959 -                         if ((fs == fs))
966 +                         let fu = invoke(W(), "withdraw", [fs], nil)
967 +                         if ((fu == fu))
960 968                              then nil
961 969                              else throw("Strict value is not equal to itself.")
962 970                          }
963 971                      else nil
964 -                 if ((fr == fr))
972 +                 if ((ft == ft))
965 973                      then {
966 -                         let fj = invoke(U(), "unlockNeutrino", [(fm - fq), toBase58String(T())], nil)
967 -                         if ((fj == fj))
974 +                         let fl = invoke(U(), "unlockNeutrino", [(fo - fs), toBase58String(T())], nil)
975 +                         if ((fl == fl))
968 976                              then {
969 -                                 let eN = invoke(X(), "notifyNotional", [toString(ei.caller), 0], nil)
970 -                                 if ((eN == eN))
971 -                                     then (((ed(toString(ei.caller)) ++ dX(bI, bJ, dc, dd, dg, de, df)) ++ ee(ei.caller, fm)) ++ eh(fp))
977 +                                 let eP = invoke(X(), "notifyNotional", [toString(ek.caller), 0], nil)
978 +                                 if ((eP == eP))
979 +                                     then (((ef(toString(ek.caller)) ++ dZ(bG, bH, de, df, di, dg, dh)) ++ eg(ek.caller, fo)) ++ ej(fr))
972 980                                      else throw("Strict value is not equal to itself.")
973 981                                  }
974 982                              else throw("Strict value is not equal to itself.")
975 983                          }
976 984                      else throw("Strict value is not equal to itself.")
977 985                  }
978 986          }
979 987  
980 988  
981 989  
982 - @Callable(ei)
990 + @Callable(ek)
983 991  func liquidate (bq) = {
984 -     let ft = cN(bq, ag)
985 -     let fi = if (cr())
992 +     let fv = cP(bq, ag)
993 +     let fk = if (ct())
986 994          then {
987 -             let fu = cN(bq, ah)
988 -             ao(ft, fu)
995 +             let fw = cP(bq, ah)
996 +             ao(fv, fw)
989 997              }
990 -         else ft
991 -     if (if (if (if (!(bi(fi, ba(), false)))
998 +         else fv
999 +     if (if (if (if (!(bi(fk, ba(), false)))
992 1000          then true
993 1001          else !(bu(bq)))
994 1002          then true
995 1003          else !(bv()))
996 1004          then true
997 1005          else bw())
998 1006          then throw("Unable to liquidate")
999 1007          else {
1000 -             let fv = cT(bq)
1001 -             let cF = fv._1
1002 -             let cd = fv._2
1003 -             let cG = fv._3
1004 -             let cH = fv._4
1005 -             let bI = fv._5
1006 -             let bJ = fv._6
1007 -             let dc = fv._7
1008 -             let dd = fv._8
1009 -             let dg = fv._9
1010 -             let db = fv._10
1011 -             let de = fv._11
1012 -             let df = fv._12
1013 -             let fw = am(db, bb())
1014 -             let fx = (fw / 2)
1015 -             let fa = (fw - fx)
1016 -             let fn = (aO() - fw)
1017 -             let fy = if ((0 > fn))
1018 -                 then $Tuple2(0, an(fn))
1019 -                 else $Tuple2(fn, 0)
1020 -             let fz = fy._1
1021 -             let fA = fy._2
1022 -             let fr = if ((fA > 0))
1008 +             let fx = cV(bq, false)
1009 +             let cH = fx._1
1010 +             let ce = fx._2
1011 +             let cI = fx._3
1012 +             let cJ = fx._4
1013 +             let bG = fx._5
1014 +             let bH = fx._6
1015 +             let de = fx._7
1016 +             let df = fx._8
1017 +             let di = fx._9
1018 +             let dd = fx._10
1019 +             let dg = fx._11
1020 +             let dh = fx._12
1021 +             let fy = am(dd, bb())
1022 +             let fz = (fy / 2)
1023 +             let fc = (fy - fz)
1024 +             let fp = (aO() - fy)
1025 +             let fA = if ((0 > fp))
1026 +                 then $Tuple2(0, an(fp))
1027 +                 else $Tuple2(fp, 0)
1028 +             let fB = fA._1
1029 +             let fC = fA._2
1030 +             let ft = if ((fC > 0))
1023 1031                  then {
1024 -                     let fs = invoke(W(), "withdraw", [fA], nil)
1025 -                     if ((fs == fs))
1032 +                     let fu = invoke(W(), "withdraw", [fC], nil)
1033 +                     if ((fu == fu))
1026 1034                          then nil
1027 1035                          else throw("Strict value is not equal to itself.")
1028 1036                      }
1029 1037                  else nil
1030 -             if ((fr == fr))
1038 +             if ((ft == ft))
1031 1039                  then {
1032 -                     let fj = invoke(U(), "unlockNeutrino", [(fw - fA), toBase58String(T())], nil)
1033 -                     if ((fj == fj))
1040 +                     let fl = invoke(U(), "unlockNeutrino", [(fy - fC), toBase58String(T())], nil)
1041 +                     if ((fl == fl))
1034 1042                          then {
1035 -                             let fc = invoke(W(), "deposit", nil, [AttachedPayment(T(), fa)])
1036 -                             if ((fc == fc))
1043 +                             let fe = invoke(W(), "deposit", nil, [AttachedPayment(T(), fc)])
1044 +                             if ((fe == fe))
1037 1045                                  then {
1038 -                                     let eN = invoke(X(), "notifyNotional", [bq, 0], nil)
1039 -                                     if ((eN == eN))
1040 -                                         then (((ed(bq) ++ dX(bI, bJ, dc, dd, dg, de, df)) ++ ee(ei.caller, fx)) ++ eh(fz))
1046 +                                     let eP = invoke(X(), "notifyNotional", [bq, 0], nil)
1047 +                                     if ((eP == eP))
1048 +                                         then (((ef(bq) ++ dZ(bG, bH, de, df, di, dg, dh)) ++ eg(ek.caller, fz)) ++ ej(fB))
1041 1049                                          else throw("Strict value is not equal to itself.")
1042 1050                                      }
1043 1051                                  else throw("Strict value is not equal to itself.")
1044 1052                              }
1045 1053                          else throw("Strict value is not equal to itself.")
1046 1054                      }
1047 1055                  else throw("Strict value is not equal to itself.")
1048 1056              }
1049 1057      }
1050 1058  
1051 1059  
1052 1060  
1053 - @Callable(ei)
1061 + @Callable(ek)
1054 1062  func payFunding () = {
1055 -     let fB = aW()
1056 -     if (if (if ((fB > lastBlock.timestamp))
1063 +     let fD = aW()
1064 +     if (if (if ((fD > lastBlock.timestamp))
1057 1065          then true
1058 1066          else !(bv()))
1059 1067          then true
1060 1068          else bw())
1061 -         then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(fB)))
1069 +         then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(fD)))
1062 1070          else {
1063 -             let fC = cl()
1064 -             let fD = dh()
1065 -             let fE = (fD - fC)
1066 -             let fF = if (if ((bg() == 0))
1071 +             let fE = cn()
1072 +             let fF = dj()
1073 +             let fG = (fF - fE)
1074 +             let fH = if (if ((bg() == 0))
1067 1075                  then true
1068 1076                  else (bh() == 0))
1069 1077                  then $Tuple2(0, 0)
1070 -                 else if ((0 > fE))
1078 +                 else if ((0 > fG))
1071 1079                      then {
1072 -                         let fG = ak(am(fE, aY()), ae)
1073 -                         let fH = ak(am(fG, bg()), bh())
1074 -                         $Tuple2(fG, fH)
1080 +                         let fI = ak(am(fG, aY()), ae)
1081 +                         let fJ = ak(am(fI, bg()), bh())
1082 +                         $Tuple2(fI, fJ)
1075 1083                          }
1076 1084                      else {
1077 -                         let fH = ak(am(fE, aY()), ae)
1078 -                         let fG = ak(am(fH, bh()), bg())
1079 -                         $Tuple2(fG, fH)
1085 +                         let fJ = ak(am(fG, aY()), ae)
1086 +                         let fI = ak(am(fJ, bh()), bg())
1087 +                         $Tuple2(fI, fJ)
1080 1088                          }
1081 -             let fG = fF._1
1082 -             let fH = fF._2
1083 -             dF((fB + aZ()), (be() + fH), (bf() + fG), ak(fH, fC), ak(fG, fC))
1089 +             let fI = fH._1
1090 +             let fJ = fH._2
1091 +             dH((fD + aZ()), (be() + fJ), (bf() + fI), ak(fJ, fE), ak(fI, fE))
1084 1092              }
1085 1093      }
1086 1094  
1087 1095  
1088 1096  
1089 - @Callable(ei)
1097 + @Callable(ek)
1090 1098  func v_get (bq) = {
1091 -     let fI = cT(bq)
1092 -     let cF = fI._1
1093 -     let cG = fI._2
1094 -     let cH = fI._3
1095 -     let fJ = fI._4
1096 -     throw((((ai(cG) + ai(cH)) + ai(fJ)) + ai(cS(bq))))
1099 +     let fK = cV(bq, false)
1100 +     let cH = fK._1
1101 +     let cI = fK._2
1102 +     let cJ = fK._3
1103 +     let fL = fK._4
1104 +     throw((((ai(cI) + ai(cJ)) + ai(fL)) + ai(cU(bq))))
1097 1105      }
1098 1106  
1099 1107  
1100 1108  
1101 - @Callable(ei)
1109 + @Callable(ek)
1102 1110  func view_calcRemainMarginWithFundingPayment (bq) = {
1103 -     let fK = bp(bq)
1104 -     let bt = fK._1
1105 -     let cx = fK._2
1106 -     let cP = fK._3
1107 -     let cz = fK._4
1108 -     let fL = cu(bq, ag)
1109 -     let cC = fL._1
1110 -     let cI = fL._2
1111 -     let fM = bT(bt, cx, cz, cI)
1112 -     let cc = fM._1
1113 -     let cd = fM._2
1114 -     let bY = fM._3
1115 -     throw((((ai(cc) + ai(bY)) + ai(cS(bq))) + ai(cI)))
1111 +     let fM = bp(bq)
1112 +     let bt = fM._1
1113 +     let cz = fM._2
1114 +     let cR = fM._3
1115 +     let cB = fM._4
1116 +     let fN = cw(bq, ag)
1117 +     let cE = fN._1
1118 +     let cK = fN._2
1119 +     let fO = bU(bt, cz, cB, cK)
1120 +     let cd = fO._1
1121 +     let ce = fO._2
1122 +     let bZ = fO._3
1123 +     throw(((((ai(cd) + ai(bZ)) + ai(cU(bq))) + ai(cK)) + ai(ce)))
1116 1124      }
1117 1125  
1118 1126  
1119 1127  
1120 - @Callable(ei)
1121 - func forceMoveAsset (bq,ef) = if (if ((addressFromPublicKey(S()) != ei.caller))
1128 + @Callable(ek)
1129 + func forceMoveAsset (bq,eh) = if (if ((addressFromPublicKey(S()) != ek.caller))
1122 1130      then true
1123 -     else (0 > ef))
1131 +     else (0 > eh))
1124 1132      then throw("Invalid forceMoveAsset parameters")
1125 1133      else {
1126 -         let fj = invoke(U(), "unlockNeutrino", [ef, toBase58String(T())], nil)
1127 -         if ((fj == fj))
1128 -             then (ee(addressFromStringValue(bq), ef) ++ eh((aO() - ef)))
1134 +         let fl = invoke(U(), "unlockNeutrino", [eh, toBase58String(T())], nil)
1135 +         if ((fl == fl))
1136 +             then (eg(addressFromStringValue(bq), eh) ++ ej((aO() - eh)))
1129 1137              else throw("Strict value is not equal to itself.")
1130 1138          }
1131 1139  
1132 1140  
1133 - @Verifier(fN)
1134 - func fO () = sigVerify(fN.bodyBytes, fN.proofs[0], S())
1141 + @Verifier(fP)
1142 + func fQ () = sigVerify(fP.bodyBytes, fP.proofs[0], S())
1135 1143

Old	New		Differences
309	309		func bD (by,bz) = {
310	310		let bE = aR()
311	311		let bF = aS()
312		-	let bG = ak(bE, bF)
313		-	let bH = ak(bz, bG)
314	312		let aN = am(bE, bF)
315		-	let bI = if (by)
	313	+	let bG = if (by)
316	314		then (bE + bz)
317	315		else (bE - bz)
318		-	let bJ = ak(aN, bI)
319		-	let bK = an((bJ - bF))
320		-	let bL = if (by)
321		-	then bK
322		-	else -(bK)
323		-	let bM = an((ak(bH, bK) - ad))
324		-	let bN = bd()
325		-	if ((bM > bN))
326		-	then throw(((((((((((((("Price impact " + toString(bM)) + " > max price impact ") + toString(bN)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " ideal price buy: ") + toString(bH)) + " real price buy: ") + toString(bK)))
	316	+	let bH = ak(aN, bG)
	317	+	let bI = an((bH - bF))
	318	+	let bJ = if (by)
	319	+	then bI
	320	+	else -(bI)
	321	+	let bK = bx(by, bz, bI)
	322	+	let bL = bK._1
	323	+	let bM = bK._2
	324	+	let bN = bK._3
	325	+	let bO = bK._4
	326	+	let bP = ak(bE, bF)
	327	+	let bQ = ak(bz, bI)
	328	+	let bR = an((bP - bQ))
	329	+	let bS = (ad - ak(bP, (bP + bR)))
	330	+	let bT = bd()
	331	+	if ((bS > bT))
	332	+	then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " price before: ") + toString(bP)) + " marketPrice: ") + toString(bQ)))
	333	+	else $Tuple5(bJ, bL, bM, bN, bO)
	334	+	}
	335	+
	336	+
	337	+	func bU (bV,bW,bX,bY) = {
	338	+	let bZ = if ((bV != 0))
	339	+	then {
	340	+	let ca = bn(bV)
	341	+	am((ca - bX), bV)
	342	+	}
	343	+	else 0
	344	+	let cb = ((bY - bZ) + bW)
	345	+	let cc = if ((0 > cb))
	346	+	then $Tuple2(0, an(cb))
	347	+	else $Tuple2(an(cb), 0)
	348	+	let cd = cc._1
	349	+	let ce = cc._2
	350	+	$Tuple3(cd, ce, bZ)
	351	+	}
	352	+
	353	+
	354	+	func cf (by,bA,cg) = {
	355	+	let ch = aR()
	356	+	let ci = aS()
	357	+	let bP = ak(ch, ci)
	358	+	if ((bA == 0))
	359	+	then throw("Invalid base asset amount")
327	360		else {
328		-	let bO = bx(by, bz, bK)
329		-	let bP = bO._1
330		-	let bQ = bO._2
331		-	let bR = bO._3
332		-	let bS = bO._4
333		-	$Tuple5(bL, bP, bQ, bR, bS)
	361	+	let aN = am(ch, ci)
	362	+	let cj = if (by)
	363	+	then (ci + bA)
	364	+	else (ci - bA)
	365	+	let ck = ak(aN, cj)
	366	+	let cl = an((ck - ch))
	367	+	let bT = bd()
	368	+	let cm = bx(!(by), cl, bA)
	369	+	let bL = cm._1
	370	+	let bM = cm._2
	371	+	let bN = cm._3
	372	+	let bO = cm._4
	373	+	let bQ = ak(cl, bA)
	374	+	let bR = an((bP - bQ))
	375	+	let bS = (ad - ak(bP, (bP + bR)))
	376	+	if (if ((bS > bT))
	377	+	then cg
	378	+	else false)
	379	+	then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(ch)) + " before base asset: ") + toString(ci)) + " base asset amount to exchange: ") + toString(bA)) + " price before: ") + toString(bP)) + " market price: ") + toString(bQ)))
	380	+	else $Tuple7(cl, bL, bM, bN, bO, (bh() - (if (by)
	381	+	then an(bA)
	382	+	else 0)), (bg() - (if (!(by))
	383	+	then an(bA)
	384	+	else 0)))
334	385		}
335	386		}
336	387
337	388
338		-	func bT (bU,bV,bW,bX) = {
339		-	let bY = if ((bU != 0))
340		-	then {
341		-	let bZ = bn(bU)
342		-	am((bZ - bW), bU)
343		-	}
344		-	else 0
345		-	let ca = ((bX - bY) + bV)
346		-	let cb = if ((0 > ca))
347		-	then $Tuple2(0, an(ca))
348		-	else $Tuple2(an(ca), 0)
349		-	let cc = cb._1
350		-	let cd = cb._2
351		-	$Tuple3(cc, cd, bY)
	389	+	func cn () = {
	390	+	let co = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
	391	+	let cp = getStringValue(this, a)
	392	+	let cq = getStringValue(this, b)
	393	+	let cr = valueOrErrorMessage(getInteger(co, cp), ((("Can not get oracle price. Oracle: " + toString(co)) + " key: ") + cp))
	394	+	cr
352	395		}
353	396
354	397
355		-	func ce (by,bA) = {
356		-	let cf = aR()
357		-	let cg = aS()
358		-	if ((bA == 0))
359		-	then throw("Invalid base asset amount")
	398	+	func cs () = {
	399	+	let ch = aR()
	400	+	let ci = aS()
	401	+	ak(ch, ci)
	402	+	}
	403	+
	404	+
	405	+	func ct () = {
	406	+	let cu = cn()
	407	+	let cv = cs()
	408	+	(ak(an((cu - cv)), cu) > bc())
	409	+	}
	410	+
	411	+
	412	+	func cw (bq,cx) = {
	413	+	let cy = bp(bq)
	414	+	let bt = cy._1
	415	+	let cz = cy._2
	416	+	let cA = cy._3
	417	+	let cB = cy._4
	418	+	let cC = an(bt)
	419	+	if ((cC == 0))
	420	+	then throw("Invalid position size")
360	421		else {
361		-	let aN = am(cf, cg)
362		-	let ch = if (by)
363		-	then (cg + bA)
364		-	else (cg - bA)
365		-	let ci = ak(aN, ch)
366		-	let cj = an((ci - cf))
367		-	let ck = bx(!(by), cj, bA)
368		-	let bP = ck._1
369		-	let bQ = ck._2
370		-	let bR = ck._3
371		-	let bS = ck._4
372		-	$Tuple7(cj, bP, bQ, bR, bS, (bh() - (if (by)
373		-	then an(bA)
374		-	else 0)), (bg() - (if (!(by))
375		-	then an(bA)
376		-	else 0)))
	422	+	let cD = (0 > bt)
	423	+	let cE = if ((cx == ag))
	424	+	then {
	425	+	let cF = cf(!(cD), cC, false)
	426	+	let cG = cF._1
	427	+	let cH = cF._2
	428	+	let cI = cF._3
	429	+	let cJ = cF._4
	430	+	cG
	431	+	}
	432	+	else am(cC, cn())
	433	+	let cK = if (cD)
	434	+	then (cA - cE)
	435	+	else (cE - cA)
	436	+	$Tuple2(cE, cK)
377	437		}
378	438		}
379	439
380	440
381		-	func cl () = {
382		-	let cm = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
383		-	let cn = getStringValue(this, a)
384		-	let co = getStringValue(this, b)
385		-	let cp = valueOrErrorMessage(getInteger(cm, cn), ((("Can not get oracle price. Oracle: " + toString(cm)) + " key: ") + cn))
386		-	cp
	441	+	func cL (cM,cN,cO) = ak((cM - cN), cO)
	442	+
	443	+
	444	+	func cP (bq,cx) = {
	445	+	let cQ = bp(bq)
	446	+	let bt = cQ._1
	447	+	let cz = cQ._2
	448	+	let cR = cQ._3
	449	+	let cB = cQ._4
	450	+	let cS = cw(bq, cx)
	451	+	let cE = cS._1
	452	+	let cK = cS._2
	453	+	let cT = bU(bt, cz, cB, cK)
	454	+	let cd = cT._1
	455	+	let ce = cT._2
	456	+	cL(cd, ce, cE)
387	457		}
388	458
389	459
390		-	func cq () = {
391		-	let cf = aR()
392		-	let cg = aS()
393		-	ak(cf, cg)
	460	+	func cU (bq) = cP(bq, ag)
	461	+
	462	+
	463	+	func cV (bq,cg) = {
	464	+	let cW = bp(bq)
	465	+	let bt = cW._1
	466	+	let cz = cW._2
	467	+	let cA = cW._3
	468	+	let cB = cW._4
	469	+	let cX = cw(bq, ag)
	470	+	let cH = cX._1
	471	+	let cK = cX._2
	472	+	let cY = bU(bt, cz, cB, cK)
	473	+	let cd = cY._1
	474	+	let ce = cY._2
	475	+	let cZ = -(bt)
	476	+	let da = cK
	477	+	let db = -(cd)
	478	+	let dc = cf((bt > 0), an(bt), cg)
	479	+	let dd = dc._1
	480	+	let bG = dc._2
	481	+	let bH = dc._3
	482	+	let de = dc._4
	483	+	let df = dc._5
	484	+	let dg = dc._6
	485	+	let dh = dc._7
	486	+	let di = (aV() - cA)
	487	+	$Tuple12(cZ, ce, da, db, bG, bH, de, df, di, dd, dg, dh)
394	488		}
395	489
396	490
397		-	func cr () = {
398		-	let cs = cl()
399		-	let ct = cq()
400		-	(ak(an((cs - ct)), cs) > bc())
401		-	}
402		-
403		-
404		-	func cu (bq,cv) = {
405		-	let cw = bp(bq)
406		-	let bt = cw._1
407		-	let cx = cw._2
408		-	let cy = cw._3
409		-	let cz = cw._4
410		-	let cA = an(bt)
411		-	if ((cA == 0))
412		-	then throw("Invalid position size")
413		-	else {
414		-	let cB = (0 > bt)
415		-	let cC = if ((cv == ag))
416		-	then {
417		-	let cD = ce(!(cB), cA)
418		-	let cE = cD._1
419		-	let cF = cD._2
420		-	let cG = cD._3
421		-	let cH = cD._4
422		-	cE
423		-	}
424		-	else am(cA, cl())
425		-	let cI = if (cB)
426		-	then (cy - cC)
427		-	else (cC - cy)
428		-	$Tuple2(cC, cI)
429		-	}
430		-	}
431		-
432		-
433		-	func cJ (cK,cL,cM) = ak((cK - cL), cM)
434		-
435		-
436		-	func cN (bq,cv) = {
437		-	let cO = bp(bq)
438		-	let bt = cO._1
439		-	let cx = cO._2
440		-	let cP = cO._3
441		-	let cz = cO._4
442		-	let cQ = cu(bq, cv)
443		-	let cC = cQ._1
444		-	let cI = cQ._2
445		-	let cR = bT(bt, cx, cz, cI)
446		-	let cc = cR._1
447		-	let cd = cR._2
448		-	cJ(cc, cd, cC)
449		-	}
450		-
451		-
452		-	func cS (bq) = cN(bq, ag)
453		-
454		-
455		-	func cT (bq) = {
456		-	let cU = bp(bq)
457		-	let bt = cU._1
458		-	let cx = cU._2
459		-	let cy = cU._3
460		-	let cz = cU._4
461		-	let cV = cu(bq, ag)
462		-	let cF = cV._1
463		-	let cI = cV._2
464		-	let cW = bT(bt, cx, cz, cI)
465		-	let cc = cW._1
466		-	let cd = cW._2
467		-	let cX = -(bt)
468		-	let cY = cI
469		-	let cZ = -(cc)
470		-	let da = ce((bt > 0), an(bt))
471		-	let db = da._1
472		-	let bI = da._2
473		-	let bJ = da._3
474		-	let dc = da._4
475		-	let dd = da._5
476		-	let de = da._6
477		-	let df = da._7
478		-	let dg = (aV() - cy)
479		-	$Tuple12(cX, cd, cY, cZ, bI, bJ, dc, dd, dg, db, de, df)
480		-	}
481		-
482		-
483		-	func dh () = {
484		-	let di = ((lastBlock.timestamp / 1000) / 60)
485		-	let dj = (di - aa)
486		-	let dk = valueOrElse(getString(this, r), "")
487		-	let dl = split(dk, ",")
488		-	func dm (av,dn) = if ((dj >= parseIntValue(dn)))
489		-	then (av :+ parseIntValue(dn))
	491	+	func dj () = {
	492	+	let dk = ((lastBlock.timestamp / 1000) / 60)
	493	+	let dl = (dk - aa)
	494	+	let dm = valueOrElse(getString(this, r), "")
	495	+	let dn = split(dm, ",")
	496	+	func do (av,dp) = if ((dl >= parseIntValue(dp)))
	497	+	then (av :+ parseIntValue(dp))
490	498		else av
491	499
492		-	let do = {
493		-	let ay = dl
	500	+	let dq = {
	501	+	let ay = dn
494	502		let az = size(ay)
495	503		let aA = nil
496	504		func aB (aC,aD) = if ((aD >= az))
497	505		then aC
498		-	else dm(aC, ay[aD])
	506	+	else do(aC, ay[aD])
499	507
500	508		func aE (aC,aD) = if ((aD >= az))
501	509		then aC

503	511
504	512		aE(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aA, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
505	513		}
506		-	let dp = if ((size(do) > 0))
507		-	then max(do)
508		-	else parseIntValue(dl[0])
509		-	let dq = valueOrElse(getInteger(this, s), 0)
510		-	let dr = valueOrElse(getInteger(this, ((t + "_") + toString(dq))), 0)
511		-	let ds = valueOrElse(getInteger(this, ((u + "_") + toString(dq))), 0)
512		-	let dt = (dr + ((~~di - dq~~) * ds))
513		-	let du = valueOrElse(getInteger(this, ((t + "_") + toString(dp))), 0)
514		-	let dv = valueOrElse(getInteger(this, ((u + "_") + toString(dp))), 0)
515		-	let dw = (du + ((~~dj - dp~~) * dv))
516		-	((~~dt - dw~~) / aa)
	514	+	let dr = if ((size(dq) > 0))
	515	+	then max(dq)
	516	+	else parseIntValue(dn[0])
	517	+	let ds = valueOrElse(getInteger(this, s), 0)
	518	+	let dt = valueOrElse(getInteger(this, ((t + "_") + toString(ds))), 0)
	519	+	let du = valueOrElse(getInteger(this, ((u + "_") + toString(ds))), 0)
	520	+	let dv = (dt + ((dk - ds) * du))
	521	+	let dw = valueOrElse(getInteger(this, ((t + "_") + toString(dr))), 0)
	522	+	let dx = valueOrElse(getInteger(this, ((u + "_") + toString(dr))), 0)
	523	+	let dy = (dw + ((dl - dr) * dx))
	524	+	((dv - dy) / aa)
517	525		}
518	526
519	527
520		-	func dx (~~dy,dz,~~dA,dB,dC,dD,dE) = [IntegerEntry(m, dy), IntegerEntry(n, dz), IntegerEntry(o, dA), IntegerEntry(l, dB), IntegerEntry(k, dC), IntegerEntry(p, dD), IntegerEntry(q, dE)]
	528	+	func dz (dA,dB,dC,dD,dE,dF,dG) = [IntegerEntry(m, dA), IntegerEntry(n, dB), IntegerEntry(o, dC), IntegerEntry(l, dD), IntegerEntry(k, dE), IntegerEntry(p, dF), IntegerEntry(q, dG)]
521	529
522	530
523		-	func dF (~~dG,dH,~~dI,dJ,dK) = [IntegerEntry(y, dG), IntegerEntry(w, dH), IntegerEntry(x, dI), IntegerEntry(z, dJ), IntegerEntry(A, dK)]
	531	+	func dH (dI,dJ,dK,dL,dM) = [IntegerEntry(y, dI), IntegerEntry(w, dJ), IntegerEntry(x, dK), IntegerEntry(z, dL), IntegerEntry(A, dM)]
524	532
525	533
526		-	func dL (ar,~~dM,dN,~~dO,bZ) = [IntegerEntry(ap(e, ar), dM), IntegerEntry(ap(f, ar), dN), IntegerEntry(ap(g, ar), dO), IntegerEntry(ap(h, ar), bZ)]
	534	+	func dN (ar,dO,dP,dQ,ca) = [IntegerEntry(ap(e, ar), dO), IntegerEntry(ap(f, ar), dP), IntegerEntry(ap(g, ar), dQ), IntegerEntry(ap(h, ar), ca)]
527	535
528	536
529		-	func dP (dQ) = {
530		-	let di = ((lastBlock.timestamp / 1000) / 60)
531		-	let dR = valueOrElse(getInteger(this, s), 0)
532		-	if ((dR > di))
	537	+	func dR (dS) = {
	538	+	let dk = ((lastBlock.timestamp / 1000) / 60)
	539	+	let dT = valueOrElse(getInteger(this, s), 0)
	540	+	if ((dT > dk))
533	541		then throw("TWAP out-of-order")
534	542		else {
535		-	let dq = if ((dR == 0))
536		-	then di
537		-	else dR
538		-	if ((di > dR))
	543	+	let ds = if ((dT == 0))
	544	+	then dk
	545	+	else dT
	546	+	if ((dk > dT))
539	547		then {
540		-	let dS = valueOrElse(getInteger(this, ((t + "_") + toString(dR))), 0)
541		-	let dT = valueOrElse(getInteger(this, ((u + "_") + toString(dR))), dQ)
542		-	let dU = (dS + ((~~di - dq~~) * dT))
543		-	let dl = aJ(aH(valueOrElse(getString(this, r), "")), aa, toString(di))
544		-	[IntegerEntry(ap(t, toString(di)), dU), IntegerEntry(ap(u, toString(di)), dQ), IntegerEntry(ap(v, toString(di)), dR), IntegerEntry(s, di), StringEntry(r, as(dl))]
	548	+	let dU = valueOrElse(getInteger(this, ((t + "_") + toString(dT))), 0)
	549	+	let dV = valueOrElse(getInteger(this, ((u + "_") + toString(dT))), dS)
	550	+	let dW = (dU + ((dk - ds) * dV))
	551	+	let dn = aJ(aH(valueOrElse(getString(this, r), "")), aa, toString(dk))
	552	+	[IntegerEntry(ap(t, toString(dk)), dW), IntegerEntry(ap(u, toString(dk)), dS), IntegerEntry(ap(v, toString(dk)), dT), IntegerEntry(s, dk), StringEntry(r, as(dn))]
545	553		}
546	554		else {
547		-	let dV = valueOrElse(getInteger(this, ap(v, toString(di))), 0)
548		-	let dS = valueOrElse(getInteger(this, ap(t, toString(dV))), 0)
549		-	let dT = valueOrElse(getInteger(this, ap(u, toString(dV))), dQ)
550		-	let dU = (dS + ((~~di - dV~~) * dT))
551		-	[IntegerEntry(ap(t, toString(di)), dU), IntegerEntry(ap(u, toString(di)), dQ)]
	555	+	let dX = valueOrElse(getInteger(this, ap(v, toString(dk))), 0)
	556	+	let dU = valueOrElse(getInteger(this, ap(t, toString(dX))), 0)
	557	+	let dV = valueOrElse(getInteger(this, ap(u, toString(dX))), dS)
	558	+	let dW = (dU + ((dk - dX) * dV))
	559	+	[IntegerEntry(ap(t, toString(dk)), dW), IntegerEntry(ap(u, toString(dk)), dS)]
552	560		}
553	561		}
554	562		}
555	563
556	564
557		-	func dW (bE,bF) = [IntegerEntry(B, bE), IntegerEntry(C, bF)]
	565	+	func dY (bE,bF) = [IntegerEntry(B, bE), IntegerEntry(C, bF)]
558	566
559	567
560		-	func dX (bE,bF,~~dY,dZ,~~ea,eb,ec) = if (((~~eb - ec~~) != dY))
561		-	then throw(((((("Invalid AMM state data: " + toString(eb)) + " + ") + toString(ec)) + " != ") + toString(dY)))
562		-	else ((dW(bE, bF) ++ [IntegerEntry(D, dY), IntegerEntry(G, dZ), IntegerEntry(H, ea), IntegerEntry(E, eb), IntegerEntry(F, ec)]) ++ dP(ak(bE, bF)))
	568	+	func dZ (bE,bF,ea,eb,ec,ed,ee) = if (((ed - ee) != ea))
	569	+	then throw(((((("Invalid AMM state data: " + toString(ed)) + " + ") + toString(ee)) + " != ") + toString(ea)))
	570	+	else ((dY(bE, bF) ++ [IntegerEntry(D, ea), IntegerEntry(G, eb), IntegerEntry(H, ec), IntegerEntry(E, ed), IntegerEntry(F, ee)]) ++ dR(ak(bE, bF)))
563	571
564	572
565		-	func ed (ar) = [DeleteEntry(ap(e, ar)), DeleteEntry(ap(f, ar)), DeleteEntry(ap(g, ar)), DeleteEntry(ap(h, ar))]
	573	+	func ef (ar) = [DeleteEntry(ap(e, ar)), DeleteEntry(ap(f, ar)), DeleteEntry(ap(g, ar)), DeleteEntry(ap(h, ar))]
566	574
567	575
568		-	func ee (ar,ef) = {
569		-	let eg = assetBalance(this, T())
570		-	if ((ef > eg))
571		-	then throw(((("Unable to withdraw " + toString(ef)) + " from contract balance ") + toString(eg)))
572		-	else [ScriptTransfer(ar, ef, T())]
	576	+	func eg (ar,eh) = {
	577	+	let ei = assetBalance(this, T())
	578	+	if ((eh > ei))
	579	+	then throw(((("Unable to withdraw " + toString(eh)) + " from contract balance ") + toString(ei)))
	580	+	else [ScriptTransfer(ar, eh, T())]
573	581		}
574	582
575	583
576		-	func eh (ei) = if ((0 > ei))
	584	+	func ej (ek) = if ((0 > ek))
577	585		then throw("Balance")
578		-	else [IntegerEntry(d, ei)]
	586	+	else [IntegerEntry(d, ek)]
579	587
580	588
581		-	func ej (ei) = [ScriptTransfer(V(), ei, T())]
	589	+	func el (ek) = [ScriptTransfer(V(), ek, T())]
582	590
583	591
584		-	@Callable(ei)
585		-	func pause () = if ((ei.caller != R()))
	592	+	@Callable(ek)
	593	+	func pause () = if ((ek.caller != R()))
586	594		then throw("Invalid togglePause params")
587	595		else [BooleanEntry(j, true)]
588	596
589	597
590	598
591		-	@Callable(ei)
592		-	func unpause () = if ((ei.caller != R()))
	599	+	@Callable(ek)
	600	+	func unpause () = if ((ek.caller != R()))

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let a = "k_ora_key"
5	5
6	6		let b = "k_ora_block_key"
7	7
8	8		let c = "k_ora"
9	9
10	10		let d = "k_balance"
11	11
12	12		let e = "k_positionSize"
13	13
14	14		let f = "k_positionMargin"
15	15
16	16		let g = "k_positionOpenNotional"
17	17
18	18		let h = "k_positionFraction"
19	19
20	20		let i = "k_initialized"
21	21
22	22		let j = "k_paused"
23	23
24	24		let k = "k_fee"
25	25
26	26		let l = "k_fundingPeriod"
27	27
28	28		let m = "k_initMarginRatio"
29	29
30	30		let n = "k_mmr"
31	31
32	32		let o = "k_liquidationFeeRatio"
33	33
34	34		let p = "k_spreadLimit"
35	35
36	36		let q = "k_maxPriceImpact"
37	37
38	38		let r = "k_lastDataStr"
39	39
40	40		let s = "k_lastMinuteId"
41	41
42	42		let t = "k_twapDataLastCumulativePrice"
43	43
44	44		let u = "k_twapDataLastPrice"
45	45
46	46		let v = "k_twapDataPreviousMinuteId"
47	47
48	48		let w = "k_latestLongPremiumFraction"
49	49
50	50		let x = "k_latestShortPremiumFraction"
51	51
52	52		let y = "k_nextFundingBlockMinTimestamp"
53	53
54	54		let z = "k_longFundingRate"
55	55
56	56		let A = "k_shortFundingRate"
57	57
58	58		let B = "k_qtAstR"
59	59
60	60		let C = "k_bsAstR"
61	61
62	62		let D = "k_totalPositionSize"
63	63
64	64		let E = "k_totalLongPositionSize"
65	65
66	66		let F = "k_totalShortPositionSize"
67	67
68	68		let G = "k_cumulativeNotional"
69	69
70	70		let H = "k_openInterestNotional"
71	71
72	72		let I = "k_coordinatorAddress"
73	73
74	74		let J = "k_insurance_address"
75	75
76	76		let K = "k_admin_address"
77	77
78	78		let L = "k_admin_public_key"
79	79
80	80		let M = "k_quote_asset"
81	81
82	82		let N = "k_quote_staking"
83	83
84	84		let O = "k_staking_address"
85	85
86	86		let P = "k_miner_address"
87	87
88	88		func Q () = valueOrErrorMessage(addressFromString(getStringValue(this, I)), "Coordinator not set")
89	89
90	90
91	91		func R () = addressFromString(getStringValue(Q(), K))
92	92
93	93
94	94		func S () = fromBase58String(getStringValue(Q(), L))
95	95
96	96
97	97		func T () = fromBase58String(getStringValue(Q(), M))
98	98
99	99
100	100		func U () = valueOrErrorMessage(addressFromString(getStringValue(Q(), N)), "Quote asset staking not set")
101	101
102	102
103	103		func V () = valueOrErrorMessage(addressFromString(getStringValue(Q(), O)), "Insurance not set")
104	104
105	105
106	106		func W () = valueOrErrorMessage(addressFromString(getStringValue(Q(), J)), "Insurance not set")
107	107
108	108
109	109		func X () = valueOrErrorMessage(addressFromString(getStringValue(Q(), P)), "Insurance not set")
110	110
111	111
112	112		let Y = 1
113	113
114	114		let Z = 2
115	115
116	116		let aa = 15
117	117
118	118		let ab = 15
119	119
120	120		let ac = 1000
121	121
122	122		let ad = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
123	123
124	124		let ae = (86400 * ad)
125	125
126	126		let af = 100
127	127
128	128		let ag = 1
129	129
130	130		let ah = 2
131	131
132	132		func ai (aj) = (toString(aj) + ",")
133	133
134	134
135	135		func ak (aj,al) = fraction(aj, ad, al, HALFEVEN)
136	136
137	137
138	138		func am (aj,al) = fraction(aj, al, ad, HALFEVEN)
139	139
140	140
141	141		func an (aj) = if ((aj > 0))
142	142		then aj
143	143		else -(aj)
144	144
145	145
146	146		func ao (aj,al) = if ((aj >= al))
147	147		then aj
148	148		else al
149	149
150	150
151	151		func ap (aq,ar) = ((aq + "_") + ar)
152	152
153	153
154	154		func as (at) = {
155	155		func au (av,aw) = ((av + aw) + ",")
156	156
157	157		let ax = {
158	158		let ay = at
159	159		let az = size(ay)
160	160		let aA = ""
161	161		func aB (aC,aD) = if ((aD >= az))
162	162		then aC
163	163		else au(aC, ay[aD])
164	164
165	165		func aE (aC,aD) = if ((aD >= az))
166	166		then aC
167	167		else throw("List size exceeds 20")
168	168
169	169		aE(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aB(aA, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
170	170		}
171	171		let aF = dropRight(ax, 1)
172	172		let aG = if ((take(aF, 1) == ","))
173	173		then drop(aF, 1)
174	174		else aF
175	175		aG
176	176		}
177	177
178	178
179	179		func aH (aI) = split(aI, ",")
180	180
181	181
182	182		func aJ (at,aK,aL) = if ((size(at) > aK))
183	183		then (removeByIndex(at, 0) :+ aL)
184	184		else (at :+ aL)
185	185
186	186
187	187		func aM (aN) = valueOrErrorMessage(getInteger(this, aN), ("no value for " + aN))
188	188
189	189
190	190		func aO () = aM(d)
191	191
192	192
193	193		func aP () = aM(k)
194	194
195	195
196	196		func aQ () = aM(m)
197	197
198	198
199	199		func aR () = aM(B)
200	200
201	201
202	202		func aS () = aM(C)
203	203
204	204
205	205		func aT () = aM(D)
206	206
207	207
208	208		func aU () = aM(G)
209	209
210	210
211	211		func aV () = aM(H)
212	212
213	213
214	214		func aW () = aM(y)
215	215
216	216
217	217		func aX () = aM(l)
218	218
219	219
220	220		func aY () = (aX() * ad)
221	221
222	222
223	223		func aZ () = (aX() * ac)
224	224
225	225
226	226		func ba () = aM(n)
227	227
228	228
229	229		func bb () = aM(o)
230	230
231	231
232	232		func bc () = aM(p)
233	233
234	234
235	235		func bd () = aM(q)
236	236
237	237
238	238		func be () = aM(w)
239	239
240	240
241	241		func bf () = aM(x)
242	242
243	243
244	244		func bg () = aM(F)
245	245
246	246
247	247		func bh () = aM(E)
248	248
249	249
250	250		func bi (bj,bk,bl) = {
251	251		let bm = (bj - bk)
252	252		if (if (bl)
253	253		then (0 > bm)
254	254		else false)
255	255		then throw("Invalid margin")
256	256		else if (if (!(bl))
257	257		then (bm >= 0)
258	258		else false)
259	259		then throw("Invalid margin")
260	260		else true
261	261		}
262	262
263	263
264	264		func bn (bo) = if ((bo == 0))
265	265		then throw("Should not be called with _positionSize == 0")
266	266		else if ((bo > 0))
267	267		then be()
268	268		else bf()
269	269
270	270
271	271		func bp (bq) = {
272	272		let br = getInteger(this, ap(e, bq))
273	273		let bs = br
274	274		if ($isInstanceOf(bs, "Int"))
275	275		then {
276	276		let bt = bs
277	277		$Tuple4(bt, getIntegerValue(this, ap(f, bq)), getIntegerValue(this, ap(g, bq)), getIntegerValue(this, ap(h, bq)))
278	278		}
279	279		else $Tuple4(0, 0, 0, 0)
280	280		}
281	281
282	282
283	283		func bu (bq) = if ((bp(bq)._1 == 0))
284	284		then throw("No open position")
285	285		else true
286	286
287	287
288	288		func bv () = valueOrElse(getBoolean(this, i), false)
289	289
290	290
291	291		func bw () = valueOrElse(getBoolean(this, j), false)
292	292
293	293
294	294		func bx (by,bz,bA) = if (by)
295	295		then {
296	296		let bB = (aS() - bA)
297	297		if ((0 >= bB))
298	298		then throw("Tx lead to base asset reserve <= 0, revert")
299	299		else $Tuple4((aR() + bz), bB, (aT() + bA), (aU() + bz))
300	300		}
301	301		else {
302	302		let bC = (aR() - bz)
303	303		if ((0 >= bC))
304	304		then throw("Tx lead to base quote reserve <= 0, revert")
305	305		else $Tuple4(bC, (aS() + bA), (aT() - bA), (aU() - bz))
306	306		}
307	307
308	308
309	309		func bD (by,bz) = {
310	310		let bE = aR()
311	311		let bF = aS()
312		-	let bG = ak(bE, bF)
313		-	let bH = ak(bz, bG)
314	312		let aN = am(bE, bF)
315		-	let bI = if (by)
	313	+	let bG = if (by)
316	314		then (bE + bz)
317	315		else (bE - bz)
318		-	let bJ = ak(aN, bI)
319		-	let bK = an((bJ - bF))
320		-	let bL = if (by)
321		-	then bK
322		-	else -(bK)
323		-	let bM = an((ak(bH, bK) - ad))
324		-	let bN = bd()
325		-	if ((bM > bN))
326		-	then throw(((((((((((((("Price impact " + toString(bM)) + " > max price impact ") + toString(bN)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " ideal price buy: ") + toString(bH)) + " real price buy: ") + toString(bK)))
	316	+	let bH = ak(aN, bG)
	317	+	let bI = an((bH - bF))
	318	+	let bJ = if (by)
	319	+	then bI
	320	+	else -(bI)
	321	+	let bK = bx(by, bz, bI)
	322	+	let bL = bK._1
	323	+	let bM = bK._2
	324	+	let bN = bK._3
	325	+	let bO = bK._4
	326	+	let bP = ak(bE, bF)
	327	+	let bQ = ak(bz, bI)
	328	+	let bR = an((bP - bQ))
	329	+	let bS = (ad - ak(bP, (bP + bR)))
	330	+	let bT = bd()
	331	+	if ((bS > bT))
	332	+	then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(bE)) + " before base asset: ") + toString(bF)) + " quote asset amount to exchange: ") + toString(bz)) + " price before: ") + toString(bP)) + " marketPrice: ") + toString(bQ)))
	333	+	else $Tuple5(bJ, bL, bM, bN, bO)
	334	+	}
	335	+
	336	+
	337	+	func bU (bV,bW,bX,bY) = {
	338	+	let bZ = if ((bV != 0))
	339	+	then {
	340	+	let ca = bn(bV)
	341	+	am((ca - bX), bV)
	342	+	}
	343	+	else 0
	344	+	let cb = ((bY - bZ) + bW)
	345	+	let cc = if ((0 > cb))
	346	+	then $Tuple2(0, an(cb))
	347	+	else $Tuple2(an(cb), 0)
	348	+	let cd = cc._1
	349	+	let ce = cc._2
	350	+	$Tuple3(cd, ce, bZ)
	351	+	}
	352	+
	353	+
	354	+	func cf (by,bA,cg) = {
	355	+	let ch = aR()
	356	+	let ci = aS()
	357	+	let bP = ak(ch, ci)
	358	+	if ((bA == 0))
	359	+	then throw("Invalid base asset amount")
327	360		else {
328		-	let bO = bx(by, bz, bK)
329		-	let bP = bO._1
330		-	let bQ = bO._2
331		-	let bR = bO._3
332		-	let bS = bO._4
333		-	$Tuple5(bL, bP, bQ, bR, bS)
	361	+	let aN = am(ch, ci)
	362	+	let cj = if (by)
	363	+	then (ci + bA)
	364	+	else (ci - bA)
	365	+	let ck = ak(aN, cj)
	366	+	let cl = an((ck - ch))
	367	+	let bT = bd()
	368	+	let cm = bx(!(by), cl, bA)
	369	+	let bL = cm._1
	370	+	let bM = cm._2
	371	+	let bN = cm._3
	372	+	let bO = cm._4
	373	+	let bQ = ak(cl, bA)
	374	+	let bR = an((bP - bQ))
	375	+	let bS = (ad - ak(bP, (bP + bR)))
	376	+	if (if ((bS > bT))
	377	+	then cg
	378	+	else false)
	379	+	then throw(((((((((((((("Price impact " + toString(bS)) + " > max price impact ") + toString(bT)) + " before quote asset: ") + toString(ch)) + " before base asset: ") + toString(ci)) + " base asset amount to exchange: ") + toString(bA)) + " price before: ") + toString(bP)) + " market price: ") + toString(bQ)))
	380	+	else $Tuple7(cl, bL, bM, bN, bO, (bh() - (if (by)
	381	+	then an(bA)
	382	+	else 0)), (bg() - (if (!(by))
	383	+	then an(bA)
	384	+	else 0)))
334	385		}
335	386		}
336	387
337	388
338		-	func bT (bU,bV,bW,bX) = {
339		-	let bY = if ((bU != 0))
340		-	then {
341		-	let bZ = bn(bU)
342		-	am((bZ - bW), bU)
343		-	}
344		-	else 0
345		-	let ca = ((bX - bY) + bV)
346		-	let cb = if ((0 > ca))
347		-	then $Tuple2(0, an(ca))
348		-	else $Tuple2(an(ca), 0)
349		-	let cc = cb._1
350		-	let cd = cb._2
351		-	$Tuple3(cc, cd, bY)
	389	+	func cn () = {
	390	+	let co = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
	391	+	let cp = getStringValue(this, a)
	392	+	let cq = getStringValue(this, b)
	393	+	let cr = valueOrErrorMessage(getInteger(co, cp), ((("Can not get oracle price. Oracle: " + toString(co)) + " key: ") + cp))
	394	+	cr
352	395		}
353	396
354	397
355		-	func ce (by,bA) = {
356		-	let cf = aR()
357		-	let cg = aS()
358		-	if ((bA == 0))
359		-	then throw("Invalid base asset amount")
	398	+	func cs () = {
	399	+	let ch = aR()
	400	+	let ci = aS()
	401	+	ak(ch, ci)
	402	+	}
	403	+
	404	+
	405	+	func ct () = {
	406	+	let cu = cn()
	407	+	let cv = cs()
	408	+	(ak(an((cu - cv)), cu) > bc())
	409	+	}
	410	+
	411	+
	412	+	func cw (bq,cx) = {
	413	+	let cy = bp(bq)
	414	+	let bt = cy._1
	415	+	let cz = cy._2
	416	+	let cA = cy._3
	417	+	let cB = cy._4
	418	+	let cC = an(bt)
	419	+	if ((cC == 0))
	420	+	then throw("Invalid position size")
360	421		else {
361		-	let aN = am(cf, cg)
362		-	let ch = if (by)
363		-	then (cg + bA)
364		-	else (cg - bA)
365		-	let ci = ak(aN, ch)
366		-	let cj = an((ci - cf))
367		-	let ck = bx(!(by), cj, bA)
368		-	let bP = ck._1
369		-	let bQ = ck._2
370		-	let bR = ck._3
371		-	let bS = ck._4
372		-	$Tuple7(cj, bP, bQ, bR, bS, (bh() - (if (by)
373		-	then an(bA)
374		-	else 0)), (bg() - (if (!(by))
375		-	then an(bA)
376		-	else 0)))
	422	+	let cD = (0 > bt)
	423	+	let cE = if ((cx == ag))
	424	+	then {
	425	+	let cF = cf(!(cD), cC, false)
	426	+	let cG = cF._1
	427	+	let cH = cF._2
	428	+	let cI = cF._3
	429	+	let cJ = cF._4
	430	+	cG
	431	+	}
	432	+	else am(cC, cn())
	433	+	let cK = if (cD)
	434	+	then (cA - cE)
	435	+	else (cE - cA)
	436	+	$Tuple2(cE, cK)
377	437		}
378	438		}
379	439
380	440
381		-	func cl () = {
382		-	let cm = valueOrErrorMessage(addressFromString(getStringValue(this, c)), "")
383		-	let cn = getStringValue(this, a)
384		-	let co = getStringValue(this, b)
385		-	let cp = valueOrErrorMessage(getInteger(cm, cn), ((("Can not get oracle price. Oracle: " + toString(cm)) + " key: ") + cn))
386		-	cp
	441	+	func cL (cM,cN,cO) = ak((cM - cN), cO)

github/deemru/w8io/169f3d6 
283.84 ms ◑