tx · 59SJ2hstPaqQt54jsmRC6yRoxQGN4NfmiLfdS27QcCBD

3Mt9TxLouqgJkMVU7KE5byxnFsBZZoj2akt:  -0.01000000 Waves

2022.01.12 13:45 [1875634] smart account 3Mt9TxLouqgJkMVU7KE5byxnFsBZZoj2akt > SELF 0.00000000 Waves

{ "type": 13, "id": "59SJ2hstPaqQt54jsmRC6yRoxQGN4NfmiLfdS27QcCBD", "fee": 1000000, "feeAssetId": null, "timestamp": 1641984345290, "version": 2, "chainId": 84, "sender": "3Mt9TxLouqgJkMVU7KE5byxnFsBZZoj2akt", "senderPublicKey": "EPELGbCtQpVU3DY9Nf1iEJtyF5R22KTaymRjPqjBsxRf", "proofs": [ "39BBsJxJd4mUUTMDVnK5eMjB1DRDgXiYusNEZ8pqQ2aPjCEu1Q53MRDKP6B6CGFhvcCKBsuV3b669TGWHPruMyUJ" ], "script": "base64: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", "height": 1875634, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: none Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func a (b) = valueOrElse(getInteger(this, b), 0)
5+
6+
7+func c (b) = valueOrElse(getString(this, b), "")
8+
9+
10+func d (b) = valueOrElse(getBoolean(this, b), false)
11+
12+
13+func e (f,b) = valueOrElse(getInteger(addressFromStringValue(f), b), 0)
14+
15+
16+func g (f,b) = valueOrElse(getString(addressFromStringValue(f), b), "")
17+
18+
19+func h (f,b) = valueOrElse(getBoolean(addressFromStringValue(f), b), false)
20+
21+
22+let i = ["GJdLSaLiv5K7xuejac8mcRcHoyo3dPrESrvktG3a6MAR", "FWVffYr2ALmHMejZm3WqeLz6Sdym3gLFGtJn4KTwyU5x", "3Wh2LaWcb5gg7K2pPcW3Ep6EAuRBzYkAgrdpt43jTDFa", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
23+
24+func j (k) = {
25+ let l = k
26+ if ($isInstanceOf(l, "Int"))
27+ then {
28+ let m = l
29+ m
30+ }
31+ else throw("Failed to cast into Int")
32+ }
33+
34+
35+let n = "__"
36+
37+let o = 100000000
38+
39+let p = 1000000
40+
41+let q = 1000000
42+
43+let r = 20000
44+
45+let s = 0
46+
47+let t = 1
48+
49+let u = 2
50+
51+let v = "NSBT-USDT"
52+
53+let w = 60
54+
55+let x = 1440
56+
57+let y = "neutrino_asset_id"
58+
59+let z = "bond_asset_id"
60+
61+let A = "auction_contract"
62+
63+let B = "liquidation_contract"
64+
65+let C = "rpd_contract"
66+
67+let D = "control_contract"
68+
69+let E = "balance_waves_lock_interval"
70+
71+let F = "balance_neutrino_lock_interval"
72+
73+let G = "min_waves_swap_amount"
74+
75+let H = "min_neutrino_swap_amount"
76+
77+let I = "node_oracle_provider"
78+
79+let J = "neutrinoOut_swap_feePart"
80+
81+let K = "wavesOut_swap_feePart"
82+
83+let L = "rand_rsa_public"
84+
85+let M = "%s__gNsbtContract"
86+
87+let N = "%s__nsbtLockContract"
88+
89+let O = "%s__dora2Contract"
90+
91+let P = "%s__quickSwapDelay"
92+
93+let Q = "%s__quickSwapLimitDuration"
94+
95+let R = "%s__dora2LastHeightLimit"
96+
97+let S = "price"
98+
99+let T = "price_index"
100+
101+let U = "is_blocked"
102+
103+func V (W) = ((S + "_") + toString(W))
104+
105+
106+func X (Y) = ((T + "_") + toString(Y))
107+
108+
109+func Z (aa) = c(makeString(["%s%d%s", "lease", toString(aa), "nodeAddress"], n))
110+
111+
112+func ab (aa) = addressFromStringValue(Z(aa))
113+
114+
115+func ac () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], n)), (1000 * o))
116+
117+
118+func ad (ae) = ("balance_unlock_block_" + ae)
119+
120+
121+func af (ag) = makeString(["%s%d%s", "lease", toString(ag), "id"], n)
122+
123+
124+func ah (ag) = makeString(["%s%d%s", "lease", toString(ag), "amount"], n)
125+
126+
127+func ai (aj) = (("min_" + aj) + "_swap_amount")
128+
129+
130+func ak (aj) = ("balance_lock_" + aj)
131+
132+
133+func al (aj,ae) = makeString(["balance_lock", aj, ae], "_")
134+
135+
136+func am (aj) = (("balance_" + aj) + "_lock_interval")
137+
138+
139+func an (aj) = (("balance_" + aj) + "_lock_interval_minimum")
140+
141+
142+func ao () = "balance_node_lock_interval"
143+
144+
145+func ap (aj) = (aj + "Out_swap_feePart")
146+
147+
148+func aq (ar) = makeString(["%s%s", "quickSwapUserSpentInPeriod", toString(ar)], n)
149+
150+
151+func as (ar) = makeString(["%s%s", "userLastQuickSwapHeight", toString(ar)], n)
152+
153+
154+func at (au) = makeString(["%s%s", "price", au], n)
155+
156+
157+func av (au) = makeString(["%s%s", "lastHeight", au], n)
158+
159+
160+func aw (aj) = valueOrElse(getInteger(this, ai(aj)), 0)
161+
162+
163+func ax (aj) = valueOrElse(getInteger(this, ak(aj)), 0)
164+
165+
166+func ay (aj,ae) = valueOrElse(getInteger(this, al(aj, ae)), 0)
167+
168+
169+func az (aj) = valueOrElse(getInteger(this, am(aj)), x)
170+
171+
172+func aA (aj) = valueOrElse(getInteger(this, an(aj)), w)
173+
174+
175+func aB () = valueOrElse(getInteger(this, ao()), 1)
176+
177+
178+func aC (aD,aE) = fraction(fraction(aD, q, aE), o, p)
179+
180+
181+func aF (aD,aE) = fraction(fraction(aD, aE, q), p, o)
182+
183+
184+func aG (aD,aE) = aF(aD, aE)
185+
186+
187+func aH (aI) = split(aI, ",")
188+
189+
190+func aJ (aj,aK) = throw(((("The specified amount in " + aj) + " swap is less than the required minimum of ") + toString(aK)))
191+
192+
193+func aL () = throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
194+
195+
196+func aM (Y,aN,aO,aP,aQ) = throw(((((((((("invalid price history index: index=" + toString(Y)) + " priceIndex=") + toString(aN)) + " indexHeight=") + toString(aO)) + " unlockHeight=") + toString(aP)) + " prevIndexHeight=") + toString(aQ)))
197+
198+
199+let aR = c(B)
200+
201+let aS = fromBase58String(c(y))
202+
203+let aT = c(A)
204+
205+let aU = c(C)
206+
207+let aV = c(D)
208+
209+let aN = e(aV, T)
210+
211+let aW = h(aV, U)
212+
213+let aX = fromBase58String(c(I))
214+
215+let aY = fromBase58String("6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g")
216+
217+let aZ = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
218+
219+let ba = fromBase64String(valueOrErrorMessage(getString(this, L), "RSA public key has not been specified"))
220+
221+let bb = this
222+
223+let bc = e(aV, S)
224+
225+let bd = ax("neutrino")
226+
227+let be = ax("waves")
228+
229+let bf = (wavesBalance(bb).regular - be)
230+
231+let bg = (((bd + value(assetInfo(aS)).quantity) - assetBalance(bb, aS)) - assetBalance(addressFromStringValue(aR), aS))
232+
233+let bh = (aF(bf, bc) - bg)
234+
235+let bi = (bg - aF(bf, bc))
236+
237+func bj (bk) = {
238+ let bl = 100000
239+ let bm = 1000
240+ let bn = aF(bl, bc)
241+ let bo = (bn * 2)
242+ let bp = fraction(bn, bm, 100)
243+ let bq = value(bk.minSponsoredAssetFee)
244+ if (if ((bq >= bo))
245+ then (bp >= bq)
246+ else false)
247+ then (bk.assetId == aS)
248+ else false
249+ }
250+
251+
252+func br (W) = e(aV, V(W))
253+
254+
255+func bs (Y) = e(aV, X(Y))
256+
257+
258+let bt = 1
259+
260+let bu = 2
261+
262+let bv = 3
263+
264+let bw = 4
265+
266+let bx = 5
267+
268+let by = 6
269+
270+let bz = 7
271+
272+let bA = 8
273+
274+let bB = 9
275+
276+let bC = 10
277+
278+let bD = 11
279+
280+let bE = 12
281+
282+let bF = 13
283+
284+let bG = 14
285+
286+let bH = 15
287+
288+let bI = 16
289+
290+func bJ (ar,bK) = makeString(["%s%s", ar, bK], n)
291+
292+
293+func bL (aj,bM,bN,aE,bO,bP,bQ,bR,bS,bT,bU,bV,Y,bW,bX,bY) = makeString(["%s%s%d%d%d%d%d%d%d%d%d%d%d%s", aj, bM, bN, aE, bO, bP, bQ, bR, bS, bT, bU, bV, Y, bW, bX, bY], n)
294+
295+
296+func bZ (aj,ca,bU) = bL(aj, "PENDING", toString(ca), "0", "0", "0", toString(height), toString(lastBlock.timestamp), "0", "0", toString(bU), "0", "0", "NULL", toString(aA(aj)), toString(az(aj)))
297+
298+
299+func cb (cc,aE,bO,bP,bV,Y,bW) = bL(cc[bt], "FINISHED", cc[bv], toString(aE), toString(bO), toString(bP), cc[bz], cc[bA], toString(height), toString(lastBlock.timestamp), cc[bD], toString(bV), toString(Y), bW, if ((15 >= size(cc)))
300+ then toString(w)
301+ else cc[bH], if ((15 >= size(cc)))
302+ then toString(x)
303+ else cc[bI])
304+
305+
306+func cd (ar,ce) = {
307+ let cf = bJ(ar, ce)
308+ split(valueOrErrorMessage(getString(this, cf), ("no swap data for " + cf)), n)
309+ }
310+
311+
312+func cg (ch,ci) = {
313+ let cj = fraction(ch, ci, p)
314+[(ch - cj), cj, ch]
315+ }
316+
317+
318+func ck (bK,cl,aj,bQ,cm) = {
319+ let cn = rsaVerify_16Kb(SHA256, toBytes(bK), cl, ba)
320+ if (!(cn))
321+ then throw("invalid RSA signature")
322+ else {
323+ let co = cm._1
324+ let cp = cm._2
325+ let cq = (toInt(sha256_16Kb(cl)) % (cp - co))
326+ let cr = (co + (if ((0 > cq))
327+ then -(cq)
328+ else cq))
329+ (bQ + cr)
330+ }
331+ }
332+
333+
334+func cs (ct) = if ((0 > ct))
335+ then -(ct)
336+ else ct
337+
338+
339+func cu (cv) = {
340+ let cw = ((wavesBalance(bb).available - cv) - ac())
341+ let cx = a(ah(0))
342+ let cy = a(ah(1))
343+ let cz = (cw + cx)
344+ let cA = (cw + cy)
345+ if (if ((cz > 0))
346+ then true
347+ else (cA > 0))
348+ then {
349+ let cB = cs((cz - cy))
350+ let cC = cs((cA - cx))
351+ if ((cC >= cB))
352+ then $Tuple2(0, cz)
353+ else $Tuple2(1, cA)
354+ }
355+ else $Tuple2(-1, 0)
356+ }
357+
358+
359+func cD (cv) = {
360+ let cE = cu(cv)
361+ let ag = cE._1
362+ let cF = cE._2
363+ if ((cF > 0))
364+ then {
365+ let cG = af(ag)
366+ let cH = getBinary(this, cG)
367+ let cI = if (isDefined(cH))
368+ then [LeaseCancel(value(cH))]
369+ else nil
370+ let cJ = ah(ag)
371+ let cK = Lease(ab(ag), cF)
372+ (cI ++ [cK, BinaryEntry(cG, calculateLeaseId(cK)), IntegerEntry(ah(ag), cF)])
373+ }
374+ else nil
375+ }
376+
377+
378+func cL () = {
379+ let cM = addressFromStringValue(getStringValue(this, O))
380+ let aE = valueOrErrorMessage(getInteger(cM, at(v)), "NSBT price is undefined")
381+ let cN = valueOrElse(getInteger(cM, av(v)), 0)
382+ $Tuple2(aE, cN)
383+ }
384+
385+
386+func cO () = {
387+ let cP = cL()
388+ let aE = cP._1
389+ let cN = cP._2
390+ aE
391+ }
392+
393+
394+func cQ (aj,cR) = {
395+ let cS = value(cR.payments[0])
396+ let cT = toString(cR.caller)
397+ let cU = toBase58String(cR.transactionId)
398+ let aK = aw(aj)
399+ let cV = ax(aj)
400+ let cW = ay(aj, cT)
401+ let cX = Z(0)
402+ let cY = if ((cX == cT))
403+ then aB()
404+ else az(aj)
405+ let bU = (height + cY)
406+ if ((aK > cS.amount))
407+ then aJ(aj, aK)
408+ else if (aW)
409+ then aL()
410+ else {
411+ let cZ = if ((aj == "waves"))
412+ then cD(0)
413+ else nil
414+ $Tuple2(([IntegerEntry(al(aj, cT), (cW + cS.amount)), IntegerEntry(ad(cT), bU), IntegerEntry(ak(aj), (cV + cS.amount)), StringEntry(bJ(cT, cU), bZ(aj, cS.amount, bU))] ++ cZ), unit)
415+ }
416+ }
417+
418+
419+func da (cR) = if ((cR.caller != this))
420+ then throw("Permission denied: this contract only allowed")
421+ else true
422+
423+
424+@Callable(cR)
425+func prepareUnleaseAndLeaseWrapper (cv) = {
426+ let db = [da(cR)]
427+ if ((db == db))
428+ then cD(cv)
429+ else throw("Strict value is not equal to itself.")
430+ }
431+
432+
433+
434+@Callable(cR)
435+func constructor (dc,dd,de,df,dg,dh,di,dj,dk,dl,dm,dn,do,dp) = {
436+ let db = da(cR)
437+ if ((db == db))
438+ then [StringEntry(y, dc), StringEntry(z, dd), StringEntry(A, de), StringEntry(B, df), StringEntry(C, dg), StringEntry(D, dh), StringEntry(I, di), StringEntry(L, dj), IntegerEntry(E, dk), IntegerEntry(F, dl), IntegerEntry(G, dm), IntegerEntry(H, dn), IntegerEntry(J, do), IntegerEntry(K, dp)]
439+ else throw("Strict value is not equal to itself.")
440+ }
441+
442+
443+
444+@Callable(cR)
445+func constructorV2 (dq,dr,cM,ds,dt,du) = {
446+ let db = da(cR)
447+ if ((db == db))
448+ then [StringEntry(M, dq), StringEntry(N, dr), StringEntry(O, cM), IntegerEntry(P, ds), IntegerEntry(Q, dt), IntegerEntry(R, du)]
449+ else throw("Strict value is not equal to itself.")
450+ }
451+
452+
453+
454+@Callable(cR)
455+func commonWithdraw (cT,Y,ce,cl,dv) = {
456+ let ar = addressFromStringValue(cT)
457+ let db = [da(cR), if (if (dv)
458+ then (cR.originCaller != ar)
459+ else false)
460+ then throw(((("Permission denied: originCaller=" + toString(cR.originCaller)) + ", account=") + cT))
461+ else true]
462+ if ((db == db))
463+ then {
464+ let cc = cd(cT, ce)
465+ let bU = parseIntValue(cc[bD])
466+ let aj = cc[bt]
467+ let bN = parseIntValue(cc[bv])
468+ let dw = cc[bu]
469+ let bQ = parseIntValue(cc[bz])
470+ let dx = if (if ((aj != "waves"))
471+ then (aj != "neutrino")
472+ else false)
473+ then throw(("Unsupported swap type " + aj))
474+ else true
475+ if ((dx == dx))
476+ then {
477+ let dy = valueOrElse(getInteger(this, ap(aj)), r)
478+ let cV = ax(aj)
479+ let cW = ay(aj, cT)
480+ let cm = if ((15 >= size(cc)))
481+ then $Tuple2(w, x)
482+ else $Tuple2(parseIntValue(cc[bH]), parseIntValue(cc[bI]))
483+ let aP = if (dv)
484+ then {
485+ let ds = getIntegerValue(this, P)
486+ (bQ + ds)
487+ }
488+ else if ((cl == base58''))
489+ then bU
490+ else ck(ce, cl, aj, bQ, cm)
491+ let aO = bs(Y)
492+ let aQ = bs((Y - 1))
493+ let dz = br(aO)
494+ let dA = if ((aj == "waves"))
495+ then $Tuple2(aF(bN, dz), aS)
496+ else $Tuple2(aC(bN, dz), unit)
497+ let dB = dA._1
498+ let dC = dA._2
499+ let dD = cg(dB, dy)
500+ let bO = dD[s]
501+ let bP = dD[t]
502+ let dt = getIntegerValue(this, Q)
503+ let dE = valueOrElse(getInteger(this, aq(ar)), 0)
504+ let dF = valueOrElse(getInteger(this, as(ar)), 0)
505+ let dr = addressFromStringValue(getStringValue(this, N))
506+ let dG = invoke(dr, "gNsbtAmountREADONLY", [toString(ar)], nil)
507+ if ((dG == dG))
508+ then {
509+ let dH = j(dG)
510+ let dI = cL()
511+ let dJ = dI._1
512+ let dK = dI._2
513+ let dL = getIntegerValue(this, R)
514+ let dM = ((height - dF) > dt)
515+ let dN = if (dM)
516+ then 0
517+ else dE
518+ let dO = fraction(dH, dJ, o)
519+ let dP = (dO - dN)
520+ let dQ = if ((aj == "neutrino"))
521+ then bN
522+ else dB
523+ let dR = [if (if (dv)
524+ then ((height - dK) > dL)
525+ else false)
526+ then throw("NSBT price is outdated")
527+ else true, if (if (dv)
528+ then (dQ > dP)
529+ else false)
530+ then throw(((("You have exceeded the quick swaps limit: limit=" + toString(dP)) + ", attemptedAmount=") + toString(dQ)))
531+ else true, if (aW)
532+ then aL()
533+ else true, if ((dw != "PENDING"))
534+ then throw("swap has been already processed")
535+ else true, if ((aP > height))
536+ then throw((("please wait for: " + toString(aP)) + " block height to withdraw funds"))
537+ else true, if (if (if ((Y > aN))
538+ then true
539+ else (aP > aO))
540+ then true
541+ else if ((aQ != 0))
542+ then (aQ >= aP)
543+ else false)
544+ then aM(Y, aN, aO, aP, aQ)
545+ else true, if ((0 >= dD[u]))
546+ then throw("balance equals zero")
547+ else true, if (if ((0 > dy))
548+ then true
549+ else (dy >= p))
550+ then throw(((("invalid outFeePart config for " + aj) + " swap: outFeePart=") + toString(dy)))
551+ else true]
552+ if ((dR == dR))
553+ then {
554+ let cZ = if (if ((aj == "neutrino"))
555+ then (dB > 0)
556+ else false)
557+ then invoke(this, "prepareUnleaseAndLeaseWrapper", [dB], nil)
558+ else unit
559+ if ((cZ == cZ))
560+ then {
561+ let dq = addressFromStringValue(getStringValue(this, M))
562+ let dS = invoke(dq, "deposit", nil, [AttachedPayment(dC, bP)])
563+ if ((dS == dS))
564+ then {
565+ let dT = if (dv)
566+ then [IntegerEntry(aq(ar), (dQ + dN)), IntegerEntry(as(ar), height)]
567+ else nil
568+ (dT ++ [IntegerEntry(al(aj, cT), (cW - bN)), IntegerEntry(ak(aj), (cV - bN)), ScriptTransfer(ar, bO, dC), StringEntry(bJ(cT, ce), cb(cc, dz, bO, bP, aP, Y, toBase58String(cR.transactionId)))])
569+ }
570+ else throw("Strict value is not equal to itself.")
571+ }
572+ else throw("Strict value is not equal to itself.")
573+ }
574+ else throw("Strict value is not equal to itself.")
575+ }
576+ else throw("Strict value is not equal to itself.")
577+ }
578+ else throw("Strict value is not equal to itself.")
579+ }
580+ else throw("Strict value is not equal to itself.")
581+ }
582+
583+
584+
585+@Callable(cR)
586+func swapWavesToNeutrino () = {
587+ let cS = value(cR.payments[0])
588+ if (isDefined(cS.assetId))
589+ then throw("Only Waves token is allowed for swapping.")
590+ else cQ("waves", cR)
591+ }
592+
593+
594+
595+@Callable(cR)
596+func swapNeutrinoToWaves () = {
597+ let cS = value(cR.payments[0])
598+ if ((cS.assetId != aS))
599+ then throw("Only appropriate Neutrino tokens are allowed for swapping.")
600+ else cQ("neutrino", cR)
601+ }
602+
603+
604+
605+@Callable(cR)
606+func withdraw (cT,Y,ce) = {
607+ let dU = invoke(this, "commonWithdraw", [cT, Y, ce, base58'', false], nil)
608+ if ((dU == dU))
609+ then nil
610+ else throw("Strict value is not equal to itself.")
611+ }
612+
613+
614+
615+@Callable(cR)
616+func withdrawV2 (cT,Y,ce,dv) = {
617+ let dU = invoke(this, "commonWithdraw", [cT, Y, ce, base58'', dv], nil)
618+ if ((dU == dU))
619+ then nil
620+ else throw("Strict value is not equal to itself.")
621+ }
622+
623+
624+
625+@Callable(cR)
626+func withdrawRand (cT,Y,ce,cl) = {
627+ let dU = invoke(this, "commonWithdraw", [cT, Y, ce, cl, false], nil)
628+ if ((dU == dU))
629+ then nil
630+ else throw("Strict value is not equal to itself.")
631+ }
632+
633+
634+
635+@Callable(cR)
636+func transferToAuction () = {
637+ let dV = (bg - assetBalance(addressFromStringValue(aT), aY))
638+ let dW = (bh - assetBalance(addressFromStringValue(aR), aS))
639+ if (aW)
640+ then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
641+ else if ((dV > (1 * p)))
642+ then [ScriptTransfer(addressFromStringValue(aT), dV, aY)]
643+ else if ((dW >= (1 * p)))
644+ then [ScriptTransfer(addressFromStringValue(aR), dW, aS)]
645+ else throw(((((((("bond were generated or do not need it. Deficit:" + toString(dV)) + "|") + toString(0)) + ". Surplus:") + toString(dW)) + "|") + toString(bh)))
646+ }
647+
648+
649+
650+@Callable(cR)
651+func acceptWaves () = if ((cR.caller != addressFromStringValue(aT)))
652+ then throw("Currently only auction contract is allowed to call")
653+ else $Tuple2(cD(0), "success")
654+
655+
656+
657+@Callable(cR)
658+func quickSwapLimitREADONLY (dX) = $Tuple2(nil, (dX * cO()))
659+
660+

github/deemru/w8io/169f3d6 
48.16 ms