tx · 5eboxr9J6DV9Enb6Xi65gwVAcsVnUdhbjJmg9JXNjB72

3N1TeiekUQhrqux6LjXWhJjUTrgLPJZxBtT:  -0.01000000 Waves

2021.11.02 11:30 [1773126] smart account 3N1TeiekUQhrqux6LjXWhJjUTrgLPJZxBtT > SELF 0.00000000 Waves

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

github/deemru/w8io/169f3d6 
40.38 ms