tx · 6auGTk5f4t2Myj441krVN4Mawg77PdAwxYxsBHnTd3MK

3NCvy36v15qPRFBCRHJ2HP16bW89fA8Pi3g:  -0.02300000 Waves

2022.12.20 11:37 [2368383] smart account 3NCvy36v15qPRFBCRHJ2HP16bW89fA8Pi3g > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6auGTk5f4t2Myj441krVN4Mawg77PdAwxYxsBHnTd3MK",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1671525501459,
    "version": 2,
    "chainId": 84,
    "sender": "3NCvy36v15qPRFBCRHJ2HP16bW89fA8Pi3g",
    "senderPublicKey": "6NPfSkwsgVtaEmVfxeaDmxsJnTVE93AxPZeNHfraGvrX",
    "proofs": [
        "j73J3D6S2zksmottD2aJ2fUfixEH1zXnWiYcywXYaQTE1hQ3X2yCZ8BqxmgwvaedrvhJviDjrVUBrGt8zNof6KD"
    ],
    "script": "base64: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",
    "height": 2368383,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = ""
5+
6+let b = "__"
7+
8+let c = 1000000
9+
10+let d = 100000000
11+
12+let e = toBigInt(c)
13+
14+let f = toBigInt(d)
15+
16+let g = toBigInt(1000000000000000000)
17+
18+let h = "WAVES"
19+
20+let i = fromBase58String(h)
21+
22+let j = 86400000
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 = 11
45+
46+func v (w,x) = valueOrErrorMessage(getString(w, x), (((("mandatory " + toString(w)) + ".") + x) + " is not defined"))
47+
48+
49+func y (x) = valueOrErrorMessage(getInteger(this, x), (("Mandatory this." + x) + " is not defined"))
50+
51+
52+func z (x,A) = valueOrElse(getString(this, x), A)
53+
54+
55+func B () = "%s__minLockAmount"
56+
57+
58+func C () = "%s__stakedAssetId"
59+
60+
61+func D () = "%s%s__config__controlAddress"
62+
63+
64+func E () = "%s__controlConfig"
65+
66+
67+func F () = "supportedRewardAssets"
68+
69+
70+func G (H) = split_4C(v(H, E()), b)
71+
72+
73+func I (J,K) = valueOrErrorMessage(addressFromString(J[K]), ("Control cfg doesn't contain address at index " + toString(K)))
74+
75+
76+let L = addressFromStringValue(valueOrElse(getString(this, D()), "3P5Bfd58PPfNvBM2Hy8QfbcDqMeNtzg7KfP"))
77+
78+let J = G(L)
79+
80+let M = I(J, n)
81+
82+let N = I(J, k)
83+
84+let O = I(J, l)
85+
86+let P = v(this, C())
87+
88+let Q = fromBase58String(P)
89+
90+let R = y(B())
91+
92+let S = z(F(), "")
93+
94+let T = split(S, "_")
95+
96+func U (V) = makeString(["%s%s%s", "paramByUser", V, "amount"], b)
97+
98+
99+func W (V) = makeString(["%s%s%s", "paramByUser", V, "start"], b)
100+
101+
102+func X (Y,V,Z) = makeString(["%s%s%s%s", "history", Y, V, toBase58String(Z)], b)
103+
104+
105+func aa () = makeString(["%s%s", "stats", "activeTotalLocked"], b)
106+
107+
108+func ab () = makeString(["%s%s", "stats", "locksCount"], b)
109+
110+
111+func ac () = makeString(["%s%s", "stats", "activeUsersCount"], b)
112+
113+
114+func ad (ae) = makeString(["%s%s%d", "stats", "depositAmtByDay", toString(ae)], b)
115+
116+
117+func af () = makeString(["%s%s%d", "stats", "depositAmtTotals"], b)
118+
119+
120+func ag () = "%s__nextPeriod"
121+
122+
123+func ah () = makeString(["%s%s%s", "dep", "lastNum"], b)
124+
125+
126+func ai (V) = makeString(["%s%s%s", "userRwdFromDepNum", V], b)
127+
128+
129+func aj (ak,al) = makeString(["%s%d", "rwdPerNsbtSumByDepNum", toString(ak), al], b)
130+
131+
132+func am (V,al) = makeString(["%s%s%s", "rwd", V, al], b)
133+
134+
135+func an (V,al) = makeString(["%s%s%s", "clm", V, al], b)
136+
137+
138+func ao (al) = makeString(["%s%s", "notDistributed", al], b)
139+
140+
141+func ap (aq,al) = makeString(["rpd_balance", al, aq], "_")
142+
143+
144+func ar (al) = makeString(["rpd_balance", al], "_")
145+
146+
147+func as (at,au) = fraction(toBigInt(at), g, au)
148+
149+
150+func av (x) = valueOrElse(getInteger(this, x), 0)
151+
152+
153+func aw (x,A) = valueOrElse(getInteger(this, x), A)
154+
155+
156+func ax (ay) = valueOrErrorMessage(addressFromString(ay), ("couldn't parse passed addressStr=" + ay))
157+
158+
159+func az (aA) = if ((aA == h))
160+    then unit
161+    else fromBase58String(aA)
162+
163+
164+func aB (aC) = {
165+    let aD = aC
166+    if ($isInstanceOf(aD, "Int"))
167+        then {
168+            let aE = aD
169+            aE
170+            }
171+        else throw("fail to cast into Int")
172+    }
173+
174+
175+func aF (aG) = {
176+    let aD = aG
177+    if ($isInstanceOf(aD, "(Int, Int, Int, Int, Int, Int, Int)"))
178+        then {
179+            let aH = aD
180+            aH
181+            }
182+        else throw("fail to cast into Int")
183+    }
184+
185+
186+func aI (V,aJ,aK) = makeString(["%s%d%d%d%d", V, toString(lastBlock.height), toString(lastBlock.timestamp), toString(aJ), toString(aK)], b)
187+
188+
189+func aL (V,aM) = makeString(["%s%d%d%s", V, toString(lastBlock.height), toString(lastBlock.timestamp), aM], b)
190+
191+
192+func aN (Y,V,Z,aJ,aK) = StringEntry(X(Y, V, Z), aI(V, aJ, aK))
193+
194+
195+func aO (V,Z,aM) = StringEntry(X("claim", V, Z), aL(V, aM))
196+
197+
198+func aP (aQ,aR,aS,aT) = {
199+    let aU = av(ab())
200+    let aV = av(ac())
201+    let aW = av(aa())
202+    let aX = (aW + aQ)
203+    $Tuple3(([IntegerEntry(ab(), (aU + aR)), IntegerEntry(ac(), (aV + aS)), IntegerEntry(aa(), aX)] ++ (if (aT)
204+        then nil
205+        else [IntegerEntry(ar(P), aX)])), aW, aX)
206+    }
207+
208+
209+func aY (V,aZ,ba,aT) = ([IntegerEntry(U(V), aZ), IntegerEntry(W(V), ba)] ++ (if (aT)
210+    then nil
211+    else [IntegerEntry(ap(V, P), aZ)]))
212+
213+
214+func bb () = $Tuple2(fromBase58String(v(this, C())), y(B()))
215+
216+
217+func bc (V) = (aw(U(V), 0) > 0)
218+
219+
220+func bd (V) = if (bc(V))
221+    then $Tuple3(false, y(U(V)), y(W(V)))
222+    else unit
223+
224+
225+func be (V) = valueOrErrorMessage(bd(V), (("User " + V) + " is not defined"))
226+
227+
228+func bf (V,bg,bh,bi,bj) = {
229+    let bk = aj(bj, bg)
230+    let bl = parseBigIntValue(z(aj(bj, bg), "0"))
231+    let bm = parseBigIntValue(z(aj(bi, bg), "0"))
232+    let bn = toInt(fraction((bl - bm), bh, g))
233+    let bo = am(V, bg)
234+    let bp = aw(bo, 0)
235+    $Tuple4((bp + bn), bp, bn, bo)
236+    }
237+
238+
239+func bq (ae) = ((ae / j) * j)
240+
241+
242+func br (bs,bt,bu) = {
243+    let bv = valueOrErrorMessage(indexOf(bs, bt), ((("there is no substring " + bt) + " in ") + bs))
244+    if ((bv == 0))
245+        then 0
246+        else {
247+            let bw = take(bs, bv)
248+            (size(split(bw, bu)) - 1)
249+            }
250+    }
251+
252+
253+let bx = "%d%d"
254+
255+func by (bz,bA,bB) = {
256+    let bC = split(bz, b)
257+    func bD (K) =     if ((K != bA))
258+        then bC[K]
259+        else toString((parseIntValue(bC[K]) + bB))
260+
261+    makeString([bx, bD(1), bD(2)], b)
262+    }
263+
264+
265+func bE (bF,bG) = {
266+    let bH = bq(lastBlock.timestamp)
267+    let bI = ad(bH)
268+    let bJ = af()
269+    let bK = br(S, bG, "_")
270+    let bL = (bx + "__0__0")
271+    let bM = valueOrElse(getString(this, bJ), bL)
272+    let bN = by(bM, (bK + 1), bF)
273+[StringEntry(bJ, bN), StringEntry(bI, bN)]
274+    }
275+
276+
277+func bO (bP,V,bQ) = {
278+    let bh = toBigInt(bQ)
279+    let bR = ai(V)
280+    let bi = aw(bR, -1)
281+    let bj = aw(ah(), -1)
282+    func bS (bT,bU) =     {
283+        let bV = bf(V, bU, bh, bi, bj)
284+        let bW = bV._1
285+        let bX = bV._2
286+        let bY = bV._3
287+        let bo = bV._4
288+        (bT :+ IntegerEntry(bo, bW))
289+        }
290+
291+    if (if ((bj == -1))
292+        then (bi == -1)
293+        else false)
294+        then nil
295+        else if (if ((bj == -1))
296+            then (bi > -1)
297+            else false)
298+            then throw("invalid depositNumLast and depositNumUser state")
299+            else if (if ((bj > -1))
300+                then (bi >= -1)
301+                else false)
302+                then if (bP)
303+                    then [IntegerEntry(bR, bj)]
304+                    else ({
305+                        let bZ = T
306+                        let ca = size(bZ)
307+                        let cb = nil
308+                        func cc (cd,ce) =                         if ((ce >= ca))
309+                            then cd
310+                            else bS(cd, bZ[ce])
311+
312+                        func cf (cd,ce) =                         if ((ce >= ca))
313+                            then cd
314+                            else throw("List size exceeds 2")
315+
316+                        cf(cc(cc(cb, 0), 1), 2)
317+                        } :+ IntegerEntry(bR, bj))
318+                else throw(((("uncovered condition: depositNumLast=" + toString(bj)) + " depositNumUser=") + toString(bi)))
319+    }
320+
321+
322+func cg (al,ch) = {
323+    let ci = ao(al)
324+    let cj = aw(ci, 0)
325+[IntegerEntry(ci, (cj + ch))]
326+    }
327+
328+
329+func ck (V,cl) = {
330+    let cm = valueOrElse(bd(V), $Tuple3(true, 0, height))
331+    let bP = cm._1
332+    let bQ = cm._2
333+    let ba = cm._3
334+    let cn = if (bP)
335+        then cl
336+        else (cl + bQ)
337+    $Tuple4(bP, bQ, ba, cn)
338+    }
339+
340+
341+func co () = {
342+    let cp = aw(ar(P), 0)
343+    let cq = aw(aa(), 0)
344+    (cp == cq)
345+    }
346+
347+
348+func cr () = if (co())
349+    then true
350+    else throw("USDN staking migration is IN PROGRESS. All operations are temporary suspended.")
351+
352+
353+func cs (V,ct,aT) = {
354+    let cu = if (!(aT))
355+        then cr()
356+        else true
357+    if ((cu == cu))
358+        then if ((size(ct.payments) != 1))
359+            then throw("Invalid payments size")
360+            else {
361+                let cv = ct.payments[0]
362+                let aZ = cv.amount
363+                let cw = (("Invalid asset. " + toBase58String(Q)) + " is expected")
364+                let bg = valueOrErrorMessage(cv.assetId, cw)
365+                if ((bg != Q))
366+                    then throw(cw)
367+                    else {
368+                        let cx = toString(V)
369+                        let cy = ck(cx, aZ)
370+                        let bP = cy._1
371+                        let bQ = cy._2
372+                        let ba = cy._3
373+                        let cn = cy._4
374+                        if ((R > cn))
375+                            then throw(("Min lock amount is " + toString(R)))
376+                            else {
377+                                let cz = aP(aZ, 1, if (bP)
378+                                    then 1
379+                                    else 0, aT)
380+                                let cA = cz._1
381+                                let cB = cz._2
382+                                let cC = cz._3
383+                                ((([aN("stake", cx, ct.transactionId, bQ, cn)] ++ bO(bP, cx, bQ)) ++ aY(cx, cn, ba, aT)) ++ cA)
384+                                }
385+                        }
386+                }
387+        else throw("Strict value is not equal to itself.")
388+    }
389+
390+
391+func cD (aZ,ct,aT) = {
392+    let cE = cr()
393+    if ((cE == cE))
394+        then if ((size(ct.payments) != 0))
395+            then throw("unstake doesn't require any payment")
396+            else {
397+                let V = ct.caller
398+                let cx = toString(V)
399+                let cF = be(cx)
400+                let bP = cF._1
401+                let bQ = cF._2
402+                let ba = cF._3
403+                if ((0 >= bQ))
404+                    then throw("Nothing to unstake")
405+                    else if ((aZ > bQ))
406+                        then throw(((("Requested " + toString(aZ)) + ", but staked only ") + toString(bQ)))
407+                        else {
408+                            let cn = (bQ - aZ)
409+                            let cG = aP(-(aZ), if ((aZ == bQ))
410+                                then -1
411+                                else 0, if ((aZ == bQ))
412+                                then -1
413+                                else 0, aT)
414+                            let cA = cG._1
415+                            let cB = cG._2
416+                            let cC = cG._3
417+                            ((([ScriptTransfer(V, aZ, Q), aN("unstake", cx, ct.transactionId, bQ, cn)] ++ bO(false, cx, bQ)) ++ aY(cx, cn, ba, aT)) ++ cA)
418+                            }
419+                }
420+        else throw("Strict value is not equal to itself.")
421+    }
422+
423+
424+func cH (V,ct) = {
425+    let cE = cr()
426+    if ((cE == cE))
427+        then {
428+            let cx = toString(V)
429+            if ((size(ct.payments) > 0))
430+                then throw("payments are not accepted")
431+                else {
432+                    let cI = valueOrElse(bd(cx), $Tuple3(true, 0, 0))
433+                    let bP = cI._1
434+                    let bQ = cI._2
435+                    let cJ = cI._3
436+                    let bh = toBigInt(bQ)
437+                    let bR = ai(cx)
438+                    let bi = aw(bR, -1)
439+                    let bj = aw(ah(), -1)
440+                    func cK (bT,bU) =                     {
441+                        let cL = bf(cx, bU, bh, bi, bj)
442+                        let bW = cL._1
443+                        let bX = cL._2
444+                        let bY = cL._3
445+                        let bo = cL._4
446+                        let cM = an(cx, bU)
447+                        let cN = bT
448+                        let cO = cN._1
449+                        let cP = cN._2
450+                        let cQ = makeString([bU, toString(bW)], ":")
451+                        let cR = makeString([cP, cQ], "_")
452+                        if ((0 >= bW))
453+                            then $Tuple2(cO, cR)
454+                            else $Tuple2((((cO :+ ScriptTransfer(V, bW, az(bU))) :+ IntegerEntry(cM, (valueOrElse(getInteger(cM), 0) + bW))) :+ IntegerEntry(bo, 0)), cR)
455+                        }
456+
457+                    let cS = {
458+                        let bZ = T
459+                        let ca = size(bZ)
460+                        let cb = $Tuple2(nil, "")
461+                        func cc (cd,ce) =                         if ((ce >= ca))
462+                            then cd
463+                            else cK(cd, bZ[ce])
464+
465+                        func cf (cd,ce) =                         if ((ce >= ca))
466+                            then cd
467+                            else throw("List size exceeds 2")
468+
469+                        cf(cc(cc(cb, 0), 1), 2)
470+                        }
471+                    let cT = cS._1
472+                    let cU = cS._2
473+                    if ((0 >= size(cT)))
474+                        then $Tuple2(nil, 0)
475+                        else $Tuple2(((cT :+ IntegerEntry(bR, bj)) :+ aO(cx, ct.transactionId, drop(cU, 1))), size(cT))
476+                    }
477+            }
478+        else throw("Strict value is not equal to itself.")
479+    }
480+
481+
482+let cV = "USDN"
483+
484+let cW = "NSBT"
485+
486+let cX = "neutrino_asset_id"
487+
488+let cY = "neutrino_contract"
489+
490+let cZ = "bond_asset_id"
491+
492+let da = "rpd_balance"
493+
494+let db = fromBase58String(v(N, cX))
495+
496+let dc = v(N, cZ)
497+
498+let dd = fromBase58String(dc)
499+
500+func de (df,bg) = makeString([da, bg, df], "_")
501+
502+
503+func dg (bg) = ((da + "_") + bg)
504+
505+
506+func dh (bg) = aw(dg(bg), 0)
507+
508+
509+func di (df,bg) = aw(de(df, bg), 0)
510+
511+
512+func dj (dk,bg) = if (if ((dk == cV))
513+    then (bg != db)
514+    else false)
515+    then throw("can use USDN only")
516+    else if (if ((dk == cW))
517+        then (bg != dd)
518+        else false)
519+        then throw("can use NSBT only")
520+        else if (if ((dk != cV))
521+            then (dk != cW)
522+            else false)
523+            then throw(("unsupported staking type " + dk))
524+            else bg
525+
526+
527+func dl (dk,ct,dm,dn) = {
528+    let do = toString(ct.caller)
529+    let bg = dj(dk, fromBase58String(dn))
530+    let dp = toBase58String(bg)
531+    let dq = (di(do, dp) - dm)
532+    if ((0 > dq))
533+        then throw("invalid amount")
534+        else $Tuple2([IntegerEntry(dg(dp), (dh(dp) - dm)), IntegerEntry(de(do, dp), dq), ScriptTransfer(addressFromStringValue(do), dm, bg)], unit)
535+    }
536+
537+
538+@Callable(ct)
539+func constructor (R,dr,ds) = if ((ct.caller != this))
540+    then throw("Permission denied")
541+    else [IntegerEntry(B(), R), StringEntry(F(), dr), StringEntry(C(), ds)]
542+
543+
544+
545+@Callable(ct)
546+func migrateUsdnStaking (cx) = {
547+    let dt = valueOrElse(getString("%s%s__cfg__leasingManagerPub"), "7AUMX54ukYMYvPmma7yoFf5NjZhs4Bu5nz3Ez9EV8sur")
548+    let du = fromBase58String(dt)
549+    if ((ct.callerPublicKey != du))
550+        then throw("migrateUsdnStaking not authorized")
551+        else if (co())
552+            then throw("migration has been done")
553+            else if ((size(ct.payments) != 0))
554+                then throw("payments are not allowed")
555+                else if ((ct.feeAssetId != unit))
556+                    then throw("fee in WAVES is allowed only")
557+                    else if ((ct.fee != 500000))
558+                        then throw("0.005 WAVES fee is allowed only")
559+                        else {
560+                            let dv = aw(ap(cx, P), 0)
561+                            if ((dv == 0))
562+                                then throw(("no need to migrate user " + cx))
563+                                else if (bc(cx))
564+                                    then throw(("already migrated user " + cx))
565+                                    else {
566+                                        let V = addressFromStringValue(cx)
567+                                        let dw = fromBase58String("")
568+                                        cs(V, Invocation([AttachedPayment(Q, dv)], V, dw, ct.transactionId, 0, unit, V, dw), true)
569+                                        }
570+                            }
571+    }
572+
573+
574+
575+@Callable(ct)
576+func stake () = cs(ct.caller, ct, false)
577+
578+
579+
580+@Callable(ct)
581+func stakeByOriginCaller () = cs(ct.originCaller, ct, false)
582+
583+
584+
585+@Callable(ct)
586+func unstake (aZ) = cD(aZ, ct, false)
587+
588+
589+
590+@Callable(ct)
591+func deposit () = {
592+    let cE = cr()
593+    if ((cE == cE))
594+        then if ((size(ct.payments) != 1))
595+            then throw("exact 1 payment is allowed only")
596+            else {
597+                let dx = ct.payments[0]
598+                let aZ = dx.amount
599+                let dy = valueOrElse(dx.assetId, i)
600+                let dz = toBase58String(dy)
601+                let dA = if ((dy == i))
602+                    then f
603+                    else e
604+                let dB = toBigInt(aZ)
605+                let cB = aw(aa(), 0)
606+                let dC = toBigInt(cB)
607+                if ((0 > cB))
608+                    then throw("TODO: case is not supported")
609+                    else if ((cB == 0))
610+                        then cg(dz, aZ)
611+                        else {
612+                            let dD = fraction(dB, g, dC)
613+                            let dE = ah()
614+                            let bj = aw(dE, -1)
615+                            let dF = (bj + 1)
616+                            if (!(contains(S, dz)))
617+                                then throw(((S + " doesn't contain ") + dz))
618+                                else {
619+                                    func dG (bT,dH) =                                     {
620+                                        let dI = aj(dF, dH)
621+                                        let dJ = z(aj(bj, dH), "0")
622+                                        (bT :+ (if ((dH == dz))
623+                                            then StringEntry(dI, toString((parseBigIntValue(dJ) + dD)))
624+                                            else StringEntry(dI, dJ)))
625+                                        }
626+
627+                                    (({
628+                                        let bZ = T
629+                                        let ca = size(bZ)
630+                                        let cb = nil
631+                                        func cc (cd,ce) =                                         if ((ce >= ca))
632+                                            then cd
633+                                            else dG(cd, bZ[ce])
634+
635+                                        func cf (cd,ce) =                                         if ((ce >= ca))
636+                                            then cd
637+                                            else throw("List size exceeds 2")
638+
639+                                        cf(cc(cc(cb, 0), 1), 2)
640+                                        } :+ IntegerEntry(dE, dF)) ++ bE(aZ, dz))
641+                                    }
642+                            }
643+                }
644+        else throw("Strict value is not equal to itself.")
645+    }
646+
647+
648+
649+@Callable(ct)
650+func claimRewards () = cH(ct.caller, ct)
651+
652+
653+
654+@Callable(ct)
655+func claimRewardsByOriginCaller () = cH(ct.originCaller, ct)
656+
657+
658+
659+@Callable(ct)
660+func unclaimedRewardsREADONLY (cx) = {
661+    func dK (bT,bU) =     ((bT + makeString([bU, "0", "0"], ":")) + "_")
662+
663+    let dL = if ((cx == ""))
664+        then {
665+            let bZ = T
666+            let ca = size(bZ)
667+            let cb = ""
668+            func cc (cd,ce) =             if ((ce >= ca))
669+                then cd
670+                else dK(cd, bZ[ce])
671+
672+            func cf (cd,ce) =             if ((ce >= ca))
673+                then cd
674+                else throw("List size exceeds 2")
675+
676+            cf(cc(cc(cb, 0), 1), 2)
677+            }
678+        else {
679+            let V = addressFromStringValue(cx)
680+            let dM = valueOrElse(bd(cx), $Tuple3(true, 0, 0))
681+            let bP = dM._1
682+            let bQ = dM._2
683+            let ba = dM._3
684+            let bh = toBigInt(bQ)
685+            let bR = ai(cx)
686+            let bi = aw(bR, -1)
687+            let bj = aw(ah(), -1)
688+            func cK (bT,bU) =             {
689+                let dN = bf(cx, bU, bh, bi, bj)
690+                let bW = dN._1
691+                let bX = dN._2
692+                let bY = dN._3
693+                let bo = dN._4
694+                let dO = valueOrElse(getInteger(an(cx, bU)), 0)
695+                ((bT + makeString([bU, toString(bW), toString(dO)], ":")) + "_")
696+                }
697+
698+            let bZ = T
699+            let ca = size(bZ)
700+            let cb = ""
701+            func cc (cd,ce) =             if ((ce >= ca))
702+                then cd
703+                else cK(cd, bZ[ce])
704+
705+            func cf (cd,ce) =             if ((ce >= ca))
706+                then cd
707+                else throw("List size exceeds 2")
708+
709+            cf(cc(cc(cb, 0), 1), 2)
710+            }
711+    $Tuple2(nil, dropRight(dL, 1))
712+    }
713+
714+
715+
716+@Callable(ct)
717+func usdnStakingSYSREADONLY (dP,dQ) = {
718+    let dR = aw(aa(), 0)
719+    if ((dP == ""))
720+        then $Tuple2(nil, [0, dR, 0])
721+        else {
722+            let V = ax(dP)
723+            let cy = ck(dP, dQ)
724+            let bP = cy._1
725+            let dS = cy._2
726+            let ba = cy._3
727+            let cn = cy._4
728+            $Tuple2(nil, [dS, dR])
729+            }
730+    }
731+
732+
733+
734+@Callable(ct)
735+func configSYSREADONLY () = {
736+    let dT = getIntegerValue(B())
737+    $Tuple2(nil, [dT])
738+    }
739+
740+
741+
742+@Callable(ct)
743+func lockNeutrinoSP (dU,dV) = cs(ct.caller, ct, false)
744+
745+
746+
747+@Callable(ct)
748+func lockNeutrino () = cs(ct.caller, ct, false)
749+
750+
751+
752+@Callable(ct)
753+func unlockNeutrino (dm,dp) = cD(dm, ct, false)
754+
755+
756+
757+@Callable(ct)
758+func unlockNsbt (dm,dp) = dl(cW, ct, dm, dp)
759+
760+
761+@Verifier(dW)
762+func dX () = {
763+    let dY = makeString(["9so3YELTNtXgo1ZXBB9NB9T6ufy6Jt3yUtfPyg11hV1v", "EYwZmURd5KKaQRBjsVa6g8DPisFoS6SovRJtFiL5gMHU", "DtmAfuDdCrHK8spdAeAYzq6MsZegeD9gnsrpuTRkCbVA", "9so3YELTNtXgo1ZXBB9NB9T6ufy6Jt3yUtfPyg11hV1v"], b)
764+    let dZ = split(valueOrElse(getString(L, "%s__multisig"), dY), b)
765+    let ea = ((((if (sigVerify(dW.bodyBytes, dW.proofs[0], fromBase58String(dZ[0])))
766+        then 1
767+        else 0) + (if (sigVerify(dW.bodyBytes, dW.proofs[1], fromBase58String(dZ[1])))
768+        then 1
769+        else 0)) + (if (sigVerify(dW.bodyBytes, dW.proofs[2], fromBase58String(dZ[2])))
770+        then 1
771+        else 0)) + (if (sigVerify(dW.bodyBytes, dW.proofs[3], fromBase58String(dZ[3])))
772+        then 2
773+        else 0))
774+    (ea >= 3)
775+    }
776+
github/deemru/w8io/873ac7e 
253.61 ms ◑