tx · GpjgmQwBBwgr3ubP99giqneYk1opkEBVNn6HLobrtqYZ

3N9KXr9JbnPwrN9oacmFjc3qB4tYrzvxWss:  -0.02800000 Waves

2022.09.16 12:57 [2231503] smart account 3N9KXr9JbnPwrN9oacmFjc3qB4tYrzvxWss > SELF 0.00000000 Waves

{ "type": 13, "id": "GpjgmQwBBwgr3ubP99giqneYk1opkEBVNn6HLobrtqYZ", "fee": 2800000, "feeAssetId": null, "timestamp": 1663322283679, "version": 1, "sender": "3N9KXr9JbnPwrN9oacmFjc3qB4tYrzvxWss", "senderPublicKey": "CuH6mrgac4GztriBQFELtAx7gw4diUcD94EVLt78E1kt", "proofs": [ "yCTQMPb3oMkyTrS8yFeHaWAYsHcToZk3MUtfV4vQW4CuFRW8ZfgGxjg4fS2yF4jcUtnK38ygfPS53BbwjEeEr8G" ], "script": "base64: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", "chainId": 84, "height": 2231503, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: FySWGaZp8PHbak2QgtQSQxbZfhm9aWfyDxVf3p7vQN5g Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = 8
5+
6+let b = 100000000
7+
8+let c = toBigInt(100000000)
9+
10+let d = toBigInt(1000000000000000000)
11+
12+let e = toBigInt(0)
13+
14+let f = "__"
15+
16+let g = 1
17+
18+let h = 2
19+
20+let i = 3
21+
22+let j = 4
23+
24+let k = 1
25+
26+let l = 2
27+
28+let m = 3
29+
30+let n = 4
31+
32+let o = 5
33+
34+let p = 6
35+
36+let q = 7
37+
38+let r = 8
39+
40+let s = 9
41+
42+let t = 10
43+
44+let u = 1
45+
46+let v = 2
47+
48+let w = 3
49+
50+let x = 1
51+
52+let y = 7
53+
54+func z (A,B) = fraction(toBigInt(A), d, toBigInt(B))
55+
56+
57+func C (D,E) = toInt(fraction(D, toBigInt(E), d))
58+
59+
60+func F (G,H,I) = fraction(G, H, I)
61+
62+
63+func J (D) = if ((e > D))
64+ then -(D)
65+ else D
66+
67+
68+func K () = "%s__factoryContract"
69+
70+
71+func L () = "%s__managerPublicKey"
72+
73+
74+func M () = "%s__pendingManagerPublicKey"
75+
76+
77+func N () = "%s%s__price__last"
78+
79+
80+func O (P,Q) = makeString(["%s%s%d%d__price__history", toString(P), toString(Q)], f)
81+
82+
83+func R (S,T) = ((("%s%s%s__P__" + S) + "__") + T)
84+
85+
86+func U (S,T) = ((("%s%s%s__G__" + S) + "__") + T)
87+
88+
89+func V () = "%s__amountAsset"
90+
91+
92+func W () = "%s__priceAsset"
93+
94+
95+func X () = "%s__factoryConfig"
96+
97+
98+func Y () = "%s%s__matcher__publicKey"
99+
100+
101+func Z (aa) = (("%s%s%s__" + aa) + "__mappings__poolContract2LpAsset")
102+
103+
104+func ab (ac,ad) = (((("%d%d%s__" + ac) + "__") + ad) + "__config")
105+
106+
107+func ae (af) = ("%s%s%s__mappings__baseAsset2internalId__" + af)
108+
109+
110+func ag () = "%s__shutdown"
111+
112+
113+func ah (ai) = ("%s%s__poolWeight__" + ai)
114+
115+
116+func aj () = "%s__allowedLpScriptHash"
117+
118+
119+func ak (al,am,an) = throw(((((("order validation failed: orderValid=" + toString(al)) + " senderValid=") + toString(am)) + " matcherValid=") + toString(an)))
120+
121+
122+func ao (ap,aq) = valueOrErrorMessage(getString(ap, aq), makeString(["mandatory ", toString(ap), ".", aq, " is not defined"], ""))
123+
124+
125+func ar (ap,aq) = valueOrErrorMessage(getInteger(ap, aq), makeString(["mandatory ", toString(ap), ".", aq, " is not defined"], ""))
126+
127+
128+let as = addressFromStringValue(ao(this, K()))
129+
130+func at () = valueOrElse(getBoolean(as, ag()), false)
131+
132+
133+func au () = fromBase58String(ao(as, Y()))
134+
135+
136+func av () = {
137+ let aw = ao(this, V())
138+ let ax = ao(this, W())
139+ let ad = ar(as, ae(ax))
140+ let ac = ar(as, ae(aw))
141+ split(ao(as, ab(toString(ac), toString(ad))), f)
142+ }
143+
144+
145+func ay () = split(ao(as, X()), f)
146+
147+
148+func az (aA,aB,aC,aD,aE,aF,aG,aH,aI,aJ) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(aA), toString(aB), toString(aC), toString(aD), toString(aE), toString(aF), toString(aG), toString(aH), toString(aI), toString(aJ)], f)
149+
150+
151+func aK (aL,aM,aN,aD,aG,aH) = makeString(["%d%d%d%d%d%d", toString(aL), toString(aM), toString(aN), toString(aD), toString(aG), toString(aH)], f)
152+
153+
154+func aO (aP) = if ((aP == "WAVES"))
155+ then wavesBalance(this).available
156+ else assetBalance(this, fromBase58String(aP))
157+
158+
159+func aQ (aR,aS) = fraction(aR, d, aS)
160+
161+
162+func aT (aU,aV,aW,aX) = {
163+ let aY = z(aW, aU)
164+ let aZ = z(aX, aV)
165+ aQ(aZ, aY)
166+ }
167+
168+
169+func ba (aW,aX,bb) = {
170+ let bc = av()
171+ let bd = parseIntValue(bc[p])
172+ let be = parseIntValue(bc[q])
173+ let bf = aT(bd, be, aW, aX)
174+ let aS = z(aW, bd)
175+ let aR = z(aX, be)
176+ let bg = z(bb, b)
177+ let bh = aQ(aS, bg)
178+ let bi = aQ(aR, bg)
179+[bf, bh, bi]
180+ }
181+
182+
183+func bj (aW,aX,bb) = {
184+ let bk = ba(aW, aX, bb)
185+[C(bk[0], b), C(bk[1], b), C(bk[2], b)]
186+ }
187+
188+
189+func bl (bm,bn,bo,S) = {
190+ let bc = av()
191+ let bp = bc[m]
192+ let bq = bc[n]
193+ let br = bc[o]
194+ let aU = parseIntValue(bc[p])
195+ let aV = parseIntValue(bc[q])
196+ let bs = bc[l]
197+ let bt = valueOrErrorMessage(assetInfo(fromBase58String(bp)), (("Asset " + bp) + " doesn't exist")).quantity
198+ if ((bp != bn))
199+ then throw("Invalid asset passed.")
200+ else {
201+ let bu = aO(bq)
202+ let bv = z(bu, aU)
203+ let bw = aO(br)
204+ let bx = z(bw, aV)
205+ let by = aQ(bx, bv)
206+ let bz = C(by, b)
207+ let bA = z(bo, b)
208+ let bB = z(bt, b)
209+ let bC = fraction(bv, bA, bB)
210+ let bD = fraction(bx, bA, bB)
211+ let bE = C(bC, aU)
212+ let bF = C(bD, aV)
213+ let bG = if ((bm == ""))
214+ then nil
215+ else [ScriptTransfer(S, bE, if ((bq == "WAVES"))
216+ then unit
217+ else fromBase58String(bq)), ScriptTransfer(S, bF, if ((br == "WAVES"))
218+ then unit
219+ else fromBase58String(br)), StringEntry(U(toString(S), bm), aK(bE, bF, bo, bz, height, lastBlock.timestamp)), IntegerEntry(N(), bz), IntegerEntry(O(height, lastBlock.timestamp), bz)]
220+ $Tuple10(bE, bF, bq, br, bu, bw, bt, by, bs, bG)
221+ }
222+ }
223+
224+
225+func bH (bm,bI,bJ,bK,bL,bM,S,bN,bO) = {
226+ let bc = av()
227+ let bp = fromBase58String(bc[m])
228+ let bP = bc[n]
229+ let bQ = bc[o]
230+ let bR = bc[r]
231+ let bS = bc[s]
232+ let bd = parseIntValue(bc[p])
233+ let be = parseIntValue(bc[q])
234+ let bs = bc[l]
235+ let bt = valueOrErrorMessage(assetInfo(bp), (("Asset " + toBase58String(bp)) + " doesn't exist")).quantity
236+ let bT = toBase58String(valueOrElse(bK, fromBase58String("WAVES")))
237+ let bU = toBase58String(valueOrElse(bM, fromBase58String("WAVES")))
238+ if (if ((bP != bT))
239+ then true
240+ else (bQ != bU))
241+ then throw("Invalid amt or price asset passed.")
242+ else {
243+ let bu = if (bN)
244+ then aO(bP)
245+ else (aO(bP) - bJ)
246+ let bw = if (bN)
247+ then aO(bQ)
248+ else (aO(bQ) - bL)
249+ let bV = z(bJ, bd)
250+ let bW = z(bL, be)
251+ let bX = aQ(bW, bV)
252+ let bv = z(bu, bd)
253+ let bx = z(bw, be)
254+ let bY = if ((bt == 0))
255+ then {
256+ let by = e
257+ let bZ = e
258+ let bg = pow((bV * bW), 0, toBigInt(5), 1, 0, DOWN)
259+ $Tuple5(C(bg, b), C(bV, bd), C(bW, be), aQ((bx + bW), (bv + bV)), bZ)
260+ }
261+ else {
262+ let by = aQ(bx, bv)
263+ let bZ = fraction(J((by - bX)), d, by)
264+ let ca = z(bI, b)
265+ if (if ((by != e))
266+ then (bZ > ca)
267+ else false)
268+ then throw(((("Price slippage " + toString(bZ)) + " exceeded the passed limit of ") + toString(ca)))
269+ else {
270+ let bB = z(bt, b)
271+ let cb = fraction(bV, by, d)
272+ let cc = fraction(bW, d, by)
273+ let cd = if ((cb > bW))
274+ then $Tuple2(cc, bW)
275+ else $Tuple2(bV, cb)
276+ let ce = cd._1
277+ let cf = cd._2
278+ let bg = fraction(bB, cf, bx)
279+ $Tuple5(C(bg, b), C(ce, bd), C(cf, be), by, bZ)
280+ }
281+ }
282+ let cg = bY._1
283+ let ch = bY._2
284+ let ci = bY._3
285+ let bz = C(bY._4, b)
286+ let cj = C(bY._5, b)
287+ if ((0 >= cg))
288+ then throw("Invalid calculations. LP calculated is less than zero.")
289+ else {
290+ let ck = if (!(bO))
291+ then 0
292+ else cg
293+ let cl = (bJ - ch)
294+ let cm = (bL - ci)
295+ let cn = [IntegerEntry(N(), bz), IntegerEntry(O(height, lastBlock.timestamp), bz), StringEntry(R(S, bm), az(ch, ci, ck, bz, bI, cj, height, lastBlock.timestamp, cl, cm))]
296+ $Tuple13(cg, ck, bz, bu, bw, bt, bp, bs, cn, cl, cm, bK, bM)
297+ }
298+ }
299+ }
300+
301+
302+func co (cp) = {
303+ let bc = av()
304+ let cq = bc[n]
305+ let cr = bc[o]
306+ let bs = parseIntValue(bc[l])
307+ let bd = parseIntValue(bc[p])
308+ let be = parseIntValue(bc[q])
309+ let cs = aO(cq)
310+ let ct = aO(cr)
311+ let by = if ((cp.orderType == Buy))
312+ then aT(bd, be, (cs + cp.amount), ct)
313+ else aT(bd, be, (cs - cp.amount), ct)
314+ let bz = C(by, b)
315+ if (if (if (at())
316+ then true
317+ else (bs == i))
318+ then true
319+ else (bs == j))
320+ then throw("Exchange operations disabled")
321+ else {
322+ let cu = cp.assetPair.amountAsset
323+ let cv = if ((cu == unit))
324+ then "WAVES"
325+ else toBase58String(value(cu))
326+ let cw = cp.assetPair.priceAsset
327+ let cx = if ((cw == unit))
328+ then "WAVES"
329+ else toBase58String(value(cw))
330+ if (if ((cv != cq))
331+ then true
332+ else (cx != cr))
333+ then throw("Wrong order assets.")
334+ else {
335+ let cy = cp.price
336+ let cz = fraction(b, be, bd)
337+ let cA = F(cy, b, cz)
338+ let cB = if ((cp.orderType == Buy))
339+ then (bz >= cA)
340+ else (cA >= bz)
341+ true
342+ }
343+ }
344+ }
345+
346+
347+func cC (cD) = if ((size(cD.payments) != 1))
348+ then throw("exactly 1 payment is expected")
349+ else {
350+ let cE = value(cD.payments[0])
351+ let bn = value(cE.assetId)
352+ let cF = cE.amount
353+ let bY = bl(toBase58String(cD.transactionId), toBase58String(bn), cF, cD.caller)
354+ let bE = bY._1
355+ let bF = bY._2
356+ let bs = parseIntValue(bY._9)
357+ let bG = bY._10
358+ if (if (at())
359+ then true
360+ else (bs == j))
361+ then throw(("Get operation is blocked by admin. Status = " + toString(bs)))
362+ else $Tuple5(bE, bF, cF, bn, bG)
363+ }
364+
365+
366+func cG (cD,bI,bO) = if ((size(cD.payments) != 2))
367+ then throw("exactly 2 payments are expected")
368+ else {
369+ let cH = value(cD.payments[0])
370+ let cI = value(cD.payments[1])
371+ let cJ = bH(toBase58String(cD.transactionId), bI, cH.amount, cH.assetId, cI.amount, cI.assetId, toString(cD.caller), false, bO)
372+ let bs = parseIntValue(cJ._8)
373+ if (if (if (at())
374+ then true
375+ else (bs == h))
376+ then true
377+ else (bs == j))
378+ then throw(("Put operation is blocked by admin. Status = " + toString(bs)))
379+ else cJ
380+ }
381+
382+
383+func cK () = {
384+ let cL = getString(L())
385+ if ($isInstanceOf(cL, "String"))
386+ then {
387+ let cM = cL
388+ fromBase58String(cM)
389+ }
390+ else if ($isInstanceOf(cL, "Unit"))
391+ then unit
392+ else throw("Match error")
393+ }
394+
395+
396+func cN () = {
397+ let cL = getString(M())
398+ if ($isInstanceOf(cL, "String"))
399+ then {
400+ let cM = cL
401+ fromBase58String(cM)
402+ }
403+ else if ($isInstanceOf(cL, "Unit"))
404+ then unit
405+ else throw("Match error")
406+ }
407+
408+
409+func cO (cD) = {
410+ let cP = throw("Permission denied")
411+ let cL = cK()
412+ if ($isInstanceOf(cL, "ByteVector"))
413+ then {
414+ let cQ = cL
415+ if ((cD.callerPublicKey == cQ))
416+ then true
417+ else cP
418+ }
419+ else if ($isInstanceOf(cL, "Unit"))
420+ then if ((cD.caller == this))
421+ then true
422+ else cP
423+ else throw("Match error")
424+ }
425+
426+
427+@Callable(cD)
428+func constructor (as) = {
429+ let cR = cO(cD)
430+ if ((cR == cR))
431+ then [StringEntry(K(), as)]
432+ else throw("Strict value is not equal to itself.")
433+ }
434+
435+
436+
437+@Callable(cD)
438+func setManager (cS) = {
439+ let cR = cO(cD)
440+ if ((cR == cR))
441+ then {
442+ let cT = fromBase58String(cS)
443+ if ((cT == cT))
444+ then [StringEntry(M(), cS)]
445+ else throw("Strict value is not equal to itself.")
446+ }
447+ else throw("Strict value is not equal to itself.")
448+ }
449+
450+
451+
452+@Callable(cD)
453+func confirmManager () = {
454+ let cU = cN()
455+ let cV = if (isDefined(cU))
456+ then true
457+ else throw("No pending manager")
458+ if ((cV == cV))
459+ then {
460+ let cW = if ((cD.callerPublicKey == value(cU)))
461+ then true
462+ else throw("You are not pending manager")
463+ if ((cW == cW))
464+ then [StringEntry(L(), toBase58String(value(cU))), DeleteEntry(M())]
465+ else throw("Strict value is not equal to itself.")
466+ }
467+ else throw("Strict value is not equal to itself.")
468+ }
469+
470+
471+
472+@Callable(cD)
473+func put (bI,cX) = {
474+ let cY = ay()
475+ let cZ = valueOrErrorMessage(addressFromString(cY[x]), "Error. Incorrect staking address.")
476+ let da = valueOrErrorMessage(addressFromString(cY[y]), "Error. Incorrect slippage contract address.")
477+ if ((0 > bI))
478+ then throw("Invalid slippageTolerance passed")
479+ else {
480+ let cJ = cG(cD, bI, true)
481+ let ck = cJ._2
482+ let bp = cJ._7
483+ let bG = cJ._9
484+ let cl = cJ._10
485+ let cm = cJ._11
486+ let db = cJ._12
487+ let dc = cJ._13
488+ let dd = invoke(as, "emit", [ck], nil)
489+ if ((dd == dd))
490+ then {
491+ let de = {
492+ let cL = dd
493+ if ($isInstanceOf(cL, "Address"))
494+ then {
495+ let df = cL
496+ invoke(df, "emit", [ck], nil)
497+ }
498+ else unit
499+ }
500+ if ((de == de))
501+ then {
502+ let dg = if ((cl > 0))
503+ then invoke(da, "put", nil, [AttachedPayment(db, cl)])
504+ else nil
505+ if ((dg == dg))
506+ then {
507+ let dh = if ((cm > 0))
508+ then invoke(da, "put", nil, [AttachedPayment(dc, cm)])
509+ else nil
510+ if ((dh == dh))
511+ then {
512+ let di = if (cX)
513+ then {
514+ let dj = invoke(cZ, "stake", nil, [AttachedPayment(bp, ck)])
515+ if ((dj == dj))
516+ then nil
517+ else throw("Strict value is not equal to itself.")
518+ }
519+ else [ScriptTransfer(cD.caller, ck, bp)]
520+ (bG ++ di)
521+ }
522+ else throw("Strict value is not equal to itself.")
523+ }
524+ else throw("Strict value is not equal to itself.")
525+ }
526+ else throw("Strict value is not equal to itself.")
527+ }
528+ else throw("Strict value is not equal to itself.")
529+ }
530+ }
531+
532+
533+
534+@Callable(cD)
535+func putForFree (dk) = if ((0 > dk))
536+ then throw("Invalid value passed")
537+ else {
538+ let cJ = cG(cD, dk, false)
539+ cJ._9
540+ }
541+
542+
543+
544+@Callable(cD)
545+func get () = {
546+ let bY = cC(cD)
547+ let dl = bY._1
548+ let bF = bY._2
549+ let cF = bY._3
550+ let bn = bY._4
551+ let bG = bY._5
552+ let dm = invoke(as, "burn", [cF], [AttachedPayment(bn, cF)])
553+ if ((dm == dm))
554+ then bG
555+ else throw("Strict value is not equal to itself.")
556+ }
557+
558+
559+
560+@Callable(cD)
561+func getNoLess (dn,do) = {
562+ let bY = cC(cD)
563+ let bE = bY._1
564+ let bF = bY._2
565+ let cF = bY._3
566+ let bn = bY._4
567+ let bG = bY._5
568+ if ((dn > bE))
569+ then throw(((("noLessThenAmtAsset failed: " + toString(bE)) + " < ") + toString(dn)))
570+ else if ((do > bF))
571+ then throw(((("noLessThenPriceAsset failed: " + toString(bF)) + " < ") + toString(do)))
572+ else {
573+ let dm = invoke(as, "burn", [cF], [AttachedPayment(bn, cF)])
574+ if ((dm == dm))
575+ then bG
576+ else throw("Strict value is not equal to itself.")
577+ }
578+ }
579+
580+
581+
582+@Callable(cD)
583+func unstakeAndGet (dp) = {
584+ let dq = if ((size(cD.payments) != 0))
585+ then throw("No payments are expected")
586+ else true
587+ if ((dq == dq))
588+ then {
589+ let bc = av()
590+ let cY = ay()
591+ let bp = fromBase58String(bc[m])
592+ let cZ = valueOrErrorMessage(addressFromString(cY[x]), "Error. Incorrect staking address.")
593+ let dr = invoke(cZ, "unstake", [toBase58String(bp), dp], nil)
594+ if ((dr == dr))
595+ then {
596+ let bY = bl(toBase58String(cD.transactionId), toBase58String(bp), dp, cD.caller)
597+ let bs = parseIntValue(bY._9)
598+ let bG = bY._10
599+ let ds = if (if (at())
600+ then true
601+ else (bs == j))
602+ then throw(("Get operation is blocked by admin. Status = " + toString(bs)))
603+ else true
604+ if ((ds == ds))
605+ then {
606+ let dm = invoke(as, "burn", [dp], [AttachedPayment(bp, dp)])
607+ if ((dm == dm))
608+ then bG
609+ else throw("Strict value is not equal to itself.")
610+ }
611+ else throw("Strict value is not equal to itself.")
612+ }
613+ else throw("Strict value is not equal to itself.")
614+ }
615+ else throw("Strict value is not equal to itself.")
616+ }
617+
618+
619+
620+@Callable(cD)
621+func activate (dt,du) = if ((toString(cD.caller) != toString(as)))
622+ then throw("permissions denied")
623+ else $Tuple2([StringEntry(V(), dt), StringEntry(W(), du)], "success")
624+
625+
626+
627+@Callable(cD)
628+func getPoolConfigWrapperREADONLY () = $Tuple2(nil, av())
629+
630+
631+
632+@Callable(cD)
633+func getAccBalanceWrapperREADONLY (aP) = $Tuple2(nil, aO(aP))
634+
635+
636+
637+@Callable(cD)
638+func calcPricesWrapperREADONLY (aW,aX,bb) = {
639+ let bk = ba(aW, aX, bb)
640+ $Tuple2(nil, [toString(bk[0]), toString(bk[1]), toString(bk[2])])
641+ }
642+
643+
644+
645+@Callable(cD)
646+func toX18WrapperREADONLY (A,B) = $Tuple2(nil, toString(z(A, B)))
647+
648+
649+
650+@Callable(cD)
651+func fromX18WrapperREADONLY (D,E) = $Tuple2(nil, C(parseBigIntValue(D), E))
652+
653+
654+
655+@Callable(cD)
656+func calcPriceBigIntWrapperREADONLY (aR,aS) = $Tuple2(nil, toString(aQ(parseBigIntValue(aR), parseBigIntValue(aS))))
657+
658+
659+
660+@Callable(cD)
661+func estimatePutOperationWrapperREADONLY (bm,bI,bJ,bK,bL,bM,S,bN,bO) = $Tuple2(nil, bH(bm, bI, bJ, bK, bL, bM, S, bN, bO))
662+
663+
664+
665+@Callable(cD)
666+func estimateGetOperationWrapperREADONLY (bm,bn,bo,S) = {
667+ let bY = bl(bm, bn, bo, addressFromStringValue(S))
668+ $Tuple2(nil, $Tuple10(bY._1, bY._2, bY._3, bY._4, bY._5, bY._6, bY._7, toString(bY._8), bY._9, bY._10))
669+ }
670+
671+
672+
673+@Callable(cD)
674+func statsREADONLY () = {
675+ let bc = av()
676+ let bp = fromBase58String(bc[m])
677+ let cq = bc[n]
678+ let cr = bc[o]
679+ let bR = bc[r]
680+ let bS = bc[s]
681+ let bd = parseIntValue(bc[p])
682+ let be = parseIntValue(bc[q])
683+ let dv = valueOrErrorMessage(assetInfo(bp), (("Asset " + toBase58String(bp)) + " doesn't exist")).quantity
684+ let cs = aO(cq)
685+ let ct = aO(cr)
686+ let dw = if ((dv == 0))
687+ then [e, e, e]
688+ else ba(cs, ct, dv)
689+ let bz = 0
690+ let dx = C(dw[1], b)
691+ let dy = C(dw[2], b)
692+ let dz = value(getInteger(as, ah(toString(this))))
693+ $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(cs), toString(ct), toString(dv), toString(bz), toString(dx), toString(dy), toString(dz)], f))
694+ }
695+
696+
697+
698+@Callable(cD)
699+func evaluatePutByAmountAssetREADONLY (bJ) = {
700+ let bc = av()
701+ let bp = fromBase58String(bc[m])
702+ let bP = bc[n]
703+ let bq = fromBase58String(bP)
704+ let bQ = bc[o]
705+ let br = fromBase58String(bQ)
706+ let bd = parseIntValue(bc[p])
707+ let be = parseIntValue(bc[q])
708+ let bs = bc[l]
709+ let dv = valueOrErrorMessage(assetInfo(bp), (("Asset " + toBase58String(bp)) + " doesn't exist")).quantity
710+ let cs = aO(bP)
711+ let ct = aO(bQ)
712+ let aY = z(cs, bd)
713+ let aZ = z(ct, be)
714+ let by = if ((dv == 0))
715+ then e
716+ else aQ(aZ, aY)
717+ let bV = z(bJ, bd)
718+ let bW = fraction(bV, by, d)
719+ let bL = C(bW, be)
720+ let cJ = bH("", 500000, bJ, bq, bL, br, "", true, false)
721+ let cg = cJ._1
722+ let dA = cJ._3
723+ let bu = cJ._4
724+ let bw = cJ._5
725+ let bt = cJ._6
726+ $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(cg), toString(C(by, b)), toString(bu), toString(bw), toString(bt), bs, toString(bJ), toString(bL)], f))
727+ }
728+
729+
730+
731+@Callable(cD)
732+func evaluatePutByPriceAssetREADONLY (bL) = {
733+ let bc = av()
734+ let bp = fromBase58String(bc[m])
735+ let bP = bc[n]
736+ let bq = fromBase58String(bP)
737+ let bQ = bc[o]
738+ let br = fromBase58String(bQ)
739+ let bd = parseIntValue(bc[p])
740+ let be = parseIntValue(bc[q])
741+ let bs = bc[l]
742+ let dv = valueOrErrorMessage(assetInfo(bp), (("Asset " + toBase58String(bp)) + " doesn't exist")).quantity
743+ let dB = aO(bP)
744+ let dC = aO(bQ)
745+ let dD = z(dB, bd)
746+ let dE = z(dC, be)
747+ let by = if ((dv == 0))
748+ then e
749+ else aQ(dE, dD)
750+ let bW = z(bL, be)
751+ let bV = fraction(bW, d, by)
752+ let bJ = C(bV, bd)
753+ let cJ = bH("", 500000, bJ, bq, bL, br, "", true, false)
754+ let cg = cJ._1
755+ let dA = cJ._3
756+ let bu = cJ._4
757+ let bw = cJ._5
758+ let bt = cJ._6
759+ $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(cg), toString(C(by, b)), toString(bu), toString(bw), toString(bt), bs, toString(bJ), toString(bL)], f))
760+ }
761+
762+
763+
764+@Callable(cD)
765+func evaluateGetREADONLY (dF,dG) = {
766+ let bY = bl("", dF, dG, this)
767+ let bE = bY._1
768+ let bF = bY._2
769+ let bu = bY._5
770+ let bw = bY._6
771+ let bt = bY._7
772+ let bz = bY._8
773+ let bs = parseIntValue(bY._9)
774+ $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(bE), toString(bF), toString(bu), toString(bw), toString(bt), toString(bz), toString(bs)], f))
775+ }
776+
777+
778+@Verifier(dH)
779+func dI () = {
780+ let dJ = {
781+ let cL = cK()
782+ if ($isInstanceOf(cL, "ByteVector"))
783+ then {
784+ let cQ = cL
785+ cQ
786+ }
787+ else if ($isInstanceOf(cL, "Unit"))
788+ then dH.senderPublicKey
789+ else throw("Match error")
790+ }
791+ let cL = dH
792+ if ($isInstanceOf(cL, "Order"))
793+ then {
794+ let cp = cL
795+ let dK = au()
796+ let al = co(cp)
797+ let am = sigVerify(cp.bodyBytes, cp.proofs[0], cp.senderPublicKey)
798+ let an = sigVerify(cp.bodyBytes, cp.proofs[1], dK)
799+ if (if (if (al)
800+ then am
801+ else false)
802+ then an
803+ else false)
804+ then true
805+ else ak(al, am, an)
806+ }
807+ else if ($isInstanceOf(cL, "SetScriptTransaction"))
808+ then {
809+ let cM = cL
810+ let dL = blake2b256(value(cM.script))
811+ let dM = fromBase64String(value(getString(as, aj())))
812+ let dN = scriptHash(this)
813+ if (if ((dM == dL))
814+ then (dN != dL)
815+ else false)
816+ then true
817+ else sigVerify(dH.bodyBytes, dH.proofs[0], dJ)
818+ }
819+ else sigVerify(dH.bodyBytes, dH.proofs[0], dJ)
820+ }
821+

github/deemru/w8io/fabc49c 
36.63 ms