tx · 5F8TkD3c4fSyJZvPtrJ7MPGJgPRMHZjKH1FpjfcRpVNX

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.02700000 Waves

2023.01.11 16:37 [2400362] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5F8TkD3c4fSyJZvPtrJ7MPGJgPRMHZjKH1FpjfcRpVNX",
    "fee": 2700000,
    "feeAssetId": null,
    "timestamp": 1673444219072,
    "version": 2,
    "chainId": 84,
    "sender": "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz",
    "senderPublicKey": "D28XoueZWsMfm8Y5pa6C5ZFuYoWgre2Wm8tzJANJgMnq",
    "proofs": [
        "3HbwWVzoE46WmC1ym7QLzXYjQVH8sQwd8Zdo5pAcHhQgi2SHBug7z2HjEJB7MUCaiYR57scdYd3R5wV1JfqT3oaX"
    ],
    "script": "base64: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",
    "height": 2400362,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GihZqBwXRmFnye3dnwFz8p98tUoFR31rKqDagkZUerB1
Next: EDTfHekTcBW1zB1qPbg39UYZs8ofTjfxvjxTHax4VwEQ

Diff: 

OldNewDifferences
260260 
261261 let aZ = ai(aj)
262262 
263-let ba = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(makeString(["%s", "lpStakingPoolsContract"], e)), i("lp_staking_pools contract address is undefined"))), i("invalid lp_staking_pools contract address"))
263+let ba = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, makeString(["%s", "lpStakingPoolsContract"], e)), i("lp_staking_pools contract address is undefined"))), i("invalid lp_staking_pools contract address"))
264264 
265265 func bb (aB) = makeString(["%s%s", aB, "nextUser"], e)
266266 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = 8
55 
66 let b = 100000000
77 
88 let c = 18
99 
1010 let d = toBigInt(1000000000000000000)
1111 
1212 let e = "__"
1313 
1414 let f = b
1515 
1616 let g = toBigInt(0)
1717 
1818 let h = toBigInt(1)
1919 
2020 func i (j) = throw(makeString(["staking.ride:", toString(this), ":", j], " "))
2121 
2222 
2323 func k (j) = throw(i(j))
2424 
2525 
2626 func l (m) = {
2727     let n = m
2828     if ($isInstanceOf(n, "List[Any]"))
2929         then {
3030             let o = n
3131             o
3232             }
3333         else throw("fail to cast into List[Any]")
3434     }
3535 
3636 
3737 func p (m) = {
3838     let n = m
3939     if ($isInstanceOf(n, "Int"))
4040         then {
4141             let q = n
4242             q
4343             }
4444         else throw("fail to cast into Int")
4545     }
4646 
4747 
4848 func r (m) = {
4949     let n = m
5050     if ($isInstanceOf(n, "String"))
5151         then {
5252             let s = n
5353             s
5454             }
5555         else throw("fail to cast into Int")
5656     }
5757 
5858 
5959 func t (m) = {
6060     let n = m
6161     if ($isInstanceOf(n, "ByteVector"))
6262         then {
6363             let u = n
6464             u
6565             }
6666         else throw("fail to cast into Int")
6767     }
6868 
6969 
7070 func v (w,x) = valueOrErrorMessage(getString(w, x), (("mandatory this." + x) + " is not defined"))
7171 
7272 
7373 func y (w,x) = valueOrErrorMessage(getString(w, x), (((("mandatory " + toString(w)) + ".") + x) + " is not defined"))
7474 
7575 
7676 func z (w,x) = valueOrElse(getInteger(w, x), 0)
7777 
7878 
7979 func A (w,x,B) = valueOrElse(getInteger(w, x), B)
8080 
8181 
8282 func C (w,x) = valueOrErrorMessage(getInteger(w, x), (("mandatory this." + x) + " is not defined"))
8383 
8484 
8585 func D (w,x) = value(parseBigInt(valueOrElse(getString(w, x), "0")))
8686 
8787 
8888 func E (w,x,B) = {
8989     let n = getString(w, x)
9090     if ($isInstanceOf(n, "String"))
9191         then {
9292             let F = n
9393             value(parseBigInt(F))
9494             }
9595         else if ($isInstanceOf(n, "Unit"))
9696             then B
9797             else throw("Match error")
9898     }
9999 
100100 
101101 func G (H,I) = fraction(toBigInt(H), d, toBigInt(I))
102102 
103103 
104104 func J (m,K) = toInt(fraction(m, toBigInt(K), d))
105105 
106106 
107107 func L () = "%s%s__config__factoryAddress"
108108 
109109 
110110 func M () = "%s__votingEmissionContract"
111111 
112112 
113113 let N = 1
114114 
115115 let O = 2
116116 
117117 let P = 3
118118 
119119 let Q = 4
120120 
121121 let R = 5
122122 
123123 let S = 6
124124 
125125 let T = 7
126126 
127127 func U () = "%s__factoryConfig"
128128 
129129 
130130 func V () = "%s__managerPublicKey"
131131 
132132 
133133 func W () = "%s__pendingManagerPublicKey"
134134 
135135 
136136 func X () = "%s__stablePoolAddonAddr"
137137 
138138 
139139 func Y () = "%s__addonAddr"
140140 
141141 
142142 func Z (aa) = makeString(["%s%s%s", aa, "mappings__lpAsset2PoolContract"], e)
143143 
144144 
145145 func ab () = "%s__lpTokensList"
146146 
147147 
148148 func ac (aa) = makeString(["%s%s%s", aa, "mappings__lpAsset2PoolContract"], e)
149149 
150150 
151151 func ad (ae) = makeString(["%s%s", "poolWeight", ae], e)
152152 
153153 
154154 func af (ag) = split(valueOrElse(getString(ag, ab()), ""), e)
155155 
156156 
157157 func ah (ag) = split(y(ag, U()), e)
158158 
159159 
160160 func ai (aj) = addressFromStringValue(aj[O])
161161 
162162 
163163 func ak (aj) = addressFromStringValue(aj[R])
164164 
165165 
166166 func al (aj) = addressFromStringValue(aj[N])
167167 
168168 
169169 func am () = "%s%s__ratePerBlock__current"
170170 
171171 
172172 func an () = "%s%s__ratePerBlockMax__current"
173173 
174174 
175175 func ao () = "%s%s__emission__startBlock"
176176 
177177 
178178 func ap () = "%s%s__emission__duration"
179179 
180180 
181181 func aq () = "%s%s__emission__endBlock"
182182 
183183 
184184 func ar (as,at) = makeString(["%s%s%s__staked", as, at], e)
185185 
186186 
187187 func au (at) = ("%s%s%s__staked__total__" + at)
188188 
189189 
190190 func av (at,as) = makeString(["%s%s%s__claimed", as, at], e)
191191 
192192 
193193 func aw (at,as) = makeString(["%s%s%s__claimedMinReward", as, at], e)
194194 
195195 
196196 func ax (at,as) = makeString(["%s%s%s__claimedBoostReward", as, at], e)
197197 
198198 
199199 func ay (at) = makeString(["%s%s%s__claimed__total", at], e)
200200 
201201 
202202 func az (x) = valueOrElse(getInteger(this, x), 0)
203203 
204204 
205205 func aA (aB) = makeString(["%s%s%s", aB, "total", "bal"], e)
206206 
207207 
208208 func aC (aB,aD) = makeString(["%s%s%s", aB, aD, "bal"], e)
209209 
210210 
211211 func aE (aB) = makeString(["%s%s%s", aB, "total", "balINT"], e)
212212 
213213 
214214 func aF (aB,aD) = makeString(["%s%s%s", aB, aD, "balINT"], e)
215215 
216216 
217217 func aG (aB) = makeString(["%s%s%s", aB, "total", "lastUpd"], e)
218218 
219219 
220220 func aH (aB,aD) = makeString(["%s%s%s", aB, aD, "lastUpd"], e)
221221 
222222 
223223 func aI (aB) = makeString(["%s%s%s%s", aB, "common", "lpInt"], e)
224224 
225225 
226226 func aJ (aB) = makeString(["%s%s%s%s", aB, "common", "lpIntH"], e)
227227 
228228 
229229 func aK (aB,aD) = makeString(["%s%s%s%s", aB, aD, "lpInt"], e)
230230 
231231 
232232 func aL (aB,aD) = makeString(["%s%s%s%s", aB, aD, "lpIntH"], e)
233233 
234234 
235235 func aM (aB) = makeString(["%s", aB, "wxPerLp"], e)
236236 
237237 
238238 func aN (aB) = makeString(["%s", aB, "wxPerLpX18"], e)
239239 
240240 
241241 func aO (aB,aD) = makeString(["%s%s%s%s", aB, aD, "uIntL"], e)
242242 
243243 
244244 func aP (aQ,aD,aR) = makeString(["%s%s%s%s__history", aQ, aD, aR], e)
245245 
246246 
247247 func aS (aD,aB,aQ,aT) = makeString(["%s%s%s%d%d%d", aD, aB, aQ, toString(height), toString(lastBlock.timestamp), toString(aT)], e)
248248 
249249 
250250 func aU (aQ,aD,aB,aT,aV) = StringEntry(aP(aQ, aD, toBase58String(aV)), aS(aD, aB, aQ, aT))
251251 
252252 
253253 let aW = v(this, L())
254254 
255255 let aX = addressFromStringValue(aW)
256256 
257257 let aj = ah(aX)
258258 
259259 let aY = ak(aj)
260260 
261261 let aZ = ai(aj)
262262 
263-let ba = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(makeString(["%s", "lpStakingPoolsContract"], e)), i("lp_staking_pools contract address is undefined"))), i("invalid lp_staking_pools contract address"))
263+let ba = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, makeString(["%s", "lpStakingPoolsContract"], e)), i("lp_staking_pools contract address is undefined"))), i("invalid lp_staking_pools contract address"))
264264 
265265 func bb (aB) = makeString(["%s%s", aB, "nextUser"], e)
266266 
267267 
268268 func bc (aB) = makeString(["users", aB], e)
269269 
270270 
271271 func bd (be) = makeString(["%s%s%s", be, "head"], e)
272272 
273273 
274274 func bf (be) = makeString(["%s%s%s", be, "size"], e)
275275 
276276 
277277 func bg (be,bh) = makeString(["%s%s%s%s", be, bh, "prev"], e)
278278 
279279 
280280 func bi (be,bh) = makeString(["%s%s%s%s", be, bh, "next"], e)
281281 
282282 
283283 func bj (be,bh) = {
284284     let bk = getString(this, bd(be))
285285     let bl = getString(this, bg(be, bh))
286286     let bm = getString(this, bi(be, bh))
287287     if (if ((bh == valueOrElse(bk, "")))
288288         then true
289289         else (bl != unit))
290290         then true
291291         else (bm != unit)
292292     }
293293 
294294 
295295 func bn (be,bh) = {
296296     let bk = getString(this, bd(be))
297297     let bo = valueOrElse(getInteger(this, bf(be)), 0)
298298     let bp = if (!(bj(be, bh)))
299299         then true
300300         else throw("Node exists")
301301     if ((bp == bp))
302302         then (([IntegerEntry(bf(be), (bo + 1))] ++ (if ((bk != unit))
303303             then [StringEntry(bi(be, bh), value(bk)), StringEntry(bg(be, value(bk)), bh)]
304304             else nil)) ++ [StringEntry(bd(be), bh)])
305305         else throw("Strict value is not equal to itself.")
306306     }
307307 
308308 
309309 func bq (be,bh) = {
310310     let bk = getString(this, bd(be))
311311     let bo = valueOrElse(getInteger(this, bf(be)), 0)
312312     let bl = getString(this, bg(be, bh))
313313     let bm = getString(this, bi(be, bh))
314314     ([IntegerEntry(bf(be), (bo - 1))] ++ (if (if ((bl != unit))
315315         then (bm != unit)
316316         else false)
317317         then [StringEntry(bi(be, value(bl)), value(bm)), StringEntry(bg(be, value(bm)), value(bl)), DeleteEntry(bg(be, bh)), DeleteEntry(bi(be, bh))]
318318         else if ((bm != unit))
319319             then [StringEntry(bd(be), value(bm)), DeleteEntry(bi(be, bh)), DeleteEntry(bg(be, value(bm)))]
320320             else if ((bl != unit))
321321                 then [DeleteEntry(bg(be, bh)), DeleteEntry(bi(be, value(bl)))]
322322                 else if ((bh == valueOrElse(bk, "")))
323323                     then [DeleteEntry(bd(be))]
324324                     else throw(((("invalid node: " + be) + ".") + bh))))
325325     }
326326 
327327 
328328 func br (bs,bt,bu,bv) = if (if ((bt == g))
329329     then (bs > g)
330330     else false)
331331     then g
332332     else if ((bs == g))
333333         then bu
334334         else if (if ((bt > g))
335335             then (bs > g)
336336             else false)
337337             then value(parseBigInt(v(this, bv)))
338338             else throw("calcWxPerLpIntegralUserLast: unexpected state")
339339 
340340 
341341 func bw (at,bx,by) = {
342342     let bz = au(at)
343343     let bA = toBigInt(az(bz))
344344     let bB = if ((bA == g))
345345         then h
346346         else bA
347347     let bC = getIntegerValue(aX, ad(bx))
348348     let bD = C(aY, ao())
349349     let bE = 1000
350350     let bF = (C(aY, am()) * bE)
351351     let bG = fraction(bF, bC, (f * 3))
352352     let bH = aI(at)
353353     let bI = aJ(at)
354354     let bJ = aM(at)
355355     let bK = A(this, bI, bD)
356356     let bL = D(this, bH)
357357     let bM = 0
358358     let bN = max([(height - bK), 0])
359359     let bO = if ((bM != 0))
360360         then toBigInt(bM)
361361         else fraction(toBigInt(bG), toBigInt(b), bB)
362362     let bP = (bA + toBigInt(by))
363363     let bQ = if ((bP == g))
364364         then h
365365         else bP
366366     let bu = (bL + (bO * toBigInt(bN)))
367367     let bR = (toBigInt(bG) / bQ)
368368     let bS = height
369369     let bT = makeString([toString(bu), toString(bN), toString(bO), toString(bA), toString(bG), toString(bF), toString(bC)], "::")
370370     $Tuple3(bu, [StringEntry(bH, toString(bu)), IntegerEntry(bI, bS), StringEntry(bJ, toString(bR))], bT)
371371     }
372372 
373373 
374374 func bU (at,as,bx,by) = {
375375     let bV = bw(at, bx, by)
376376     let bu = bV._1
377377     let bW = bV._2
378378     let bX = bV._3
379379     let bE = 1000
380380     let bY = ar(as, at)
381381     let bs = az(bY)
382382     let bZ = aK(at, as)
383383     let ca = aL(at, as)
384384     let bv = aO(at, as)
385385     let cb = D(this, bZ)
386386     let bt = z(this, ca)
387387     let cc = br(toBigInt(bs), toBigInt(bt), bu, bv)
388388     let cd = (b * bE)
389389     let ce = max([(cb + fraction((bu - cc), toBigInt(bs), toBigInt(cd))), g])
390390     let cf = bu
391391     let cg = height
392392     let bT = makeString([toString(cb), toString(cc), toString(bs), bX, toString(height)], "::")
393393     $Tuple3(ce, (bW ++ [StringEntry(bZ, toString(ce)), IntegerEntry(ca, cg), StringEntry(bv, toString(cf))]), bT)
394394     }
395395 
396396 
397397 func ch () = {
398398     let n = getString(V())
399399     if ($isInstanceOf(n, "String"))
400400         then {
401401             let F = n
402402             fromBase58String(F)
403403             }
404404         else if ($isInstanceOf(n, "Unit"))
405405             then unit
406406             else throw("Match error")
407407     }
408408 
409409 
410410 func ci () = {
411411     let n = getString(W())
412412     if ($isInstanceOf(n, "String"))
413413         then {
414414             let F = n
415415             fromBase58String(F)
416416             }
417417         else if ($isInstanceOf(n, "Unit"))
418418             then unit
419419             else throw("Match error")
420420     }
421421 
422422 
423423 let cj = throw("Permission denied")
424424 
425425 func ck (cl) = if ((cl.caller == this))
426426     then true
427427     else cj
428428 
429429 
430430 func cm (cl) = {
431431     let n = ch()
432432     if ($isInstanceOf(n, "ByteVector"))
433433         then {
434434             let cn = n
435435             if ((cl.callerPublicKey == cn))
436436                 then true
437437                 else cj
438438             }
439439         else if ($isInstanceOf(n, "Unit"))
440440             then if ((cl.caller == this))
441441                 then true
442442                 else cj
443443             else throw("Match error")
444444     }
445445 
446446 
447447 @Callable(cl)
448448 func constructor (co) = {
449449     let cp = cm(cl)
450450     if ((cp == cp))
451451         then [StringEntry(L(), co)]
452452         else throw("Strict value is not equal to itself.")
453453     }
454454 
455455 
456456 
457457 @Callable(cl)
458458 func constructorV2 (cq) = {
459459     let cr = [cm(cl), if ((addressFromString(cq) != unit))
460460         then true
461461         else "invalid voting emission contract address"]
462462     if ((cr == cr))
463463         then [StringEntry(M(), cq)]
464464         else throw("Strict value is not equal to itself.")
465465     }
466466 
467467 
468468 
469469 @Callable(cl)
470470 func setManager (cs) = {
471471     let cp = cm(cl)
472472     if ((cp == cp))
473473         then {
474474             let ct = fromBase58String(cs)
475475             if ((ct == ct))
476476                 then [StringEntry(W(), cs)]
477477                 else throw("Strict value is not equal to itself.")
478478             }
479479         else throw("Strict value is not equal to itself.")
480480     }
481481 
482482 
483483 
484484 @Callable(cl)
485485 func confirmManager () = {
486486     let cu = ci()
487487     let cv = if (isDefined(cu))
488488         then true
489489         else throw("No pending manager")
490490     if ((cv == cv))
491491         then {
492492             let cw = if ((cl.callerPublicKey == value(cu)))
493493                 then true
494494                 else throw("You are not pending manager")
495495             if ((cw == cw))
496496                 then [StringEntry(V(), toBase58String(value(cu))), DeleteEntry(W())]
497497                 else throw("Strict value is not equal to itself.")
498498             }
499499         else throw("Strict value is not equal to itself.")
500500     }
501501 
502502 
503503 
504504 @Callable(cl)
505505 func stake () = if ((size(cl.payments) != 1))
506506     then throw("invalid payment - exact one payment must be attached")
507507     else {
508508         let cx = cl.payments[0]
509509         let aB = value(cx.assetId)
510510         let at = toBase58String(aB)
511511         let aT = cx.amount
512512         let bx = valueOrErrorMessage(getString(aX, Z(at)), ("unsupported lp asset " + at))
513513         let cy = toString(cl.caller)
514514         let as = if ((cy == bx))
515515             then toString(cl.originCaller)
516516             else cy
517517         let bY = ar(as, at)
518518         let bz = au(at)
519519         let bs = az(bY)
520520         let bA = az(bz)
521521         let cz = bU(at, as, bx, aT)
522522         let ce = cz._1
523523         let cA = cz._2
524524         let bT = cz._3
525525         let be = bc(at)
526526         let cB = if (bj(be, as))
527527             then nil
528528             else bn(be, as)
529529         (([IntegerEntry(bY, (bs + aT)), IntegerEntry(bz, (bA + aT)), aU("stake", as, at, aT, cl.transactionId)] ++ cA) ++ cB)
530530         }
531531 
532532 
533533 
534534 @Callable(cl)
535535 func unstake (at,aT) = {
536536     let aB = fromBase58String(at)
537537     let bx = valueOrErrorMessage(getString(aX, Z(at)), ("unsupported lp asset " + at))
538538     let cC = valueOrElse(getString(addressFromStringValue(bx), Y()), bx)
539539     let cy = toString(cl.caller)
540540     let as = if (if (if ((cy == bx))
541541         then (cl.originCaller != ba)
542542         else false)
543543         then true
544544         else (cy == cC))
545545         then toString(cl.originCaller)
546546         else cy
547547     let bY = ar(as, at)
548548     let bz = au(at)
549549     let bs = az(bY)
550550     let bA = az(bz)
551551     let cA = bU(at, as, bx, -(aT))._2
552552     let be = bc(at)
553553     let cB = if (if (bj(be, as))
554554         then (aT == bs)
555555         else false)
556556         then bq(be, as)
557557         else nil
558558     let cD = D(this, av(at, as))
559559     let cE = y(aX, ac(at))
560560     let ce = bU(at, as, cE, 0)._1
561561     let cF = (ce - cD)
562562     let cG = if ((cF > g))
563563         then invoke(this, "claimWxINTERNAL", [at, as], nil)
564564         else unit
565565     if ((cG == cG))
566566         then if ((aT > bs))
567567             then throw(((((((("passed amount=" + toString(aT)) + " is greater than available=") + toString(bs)) + ". lpAssetId=") + at) + ". stakedByUserKEY=") + bY))
568568             else (([IntegerEntry(bY, (bs - aT)), IntegerEntry(bz, (bA - aT)), ScriptTransfer(cl.caller, aT, aB), aU("unstake", as, at, aT, cl.transactionId)] ++ cA) ++ cB)
569569         else throw("Strict value is not equal to itself.")
570570     }
571571 
572572 
573573 
574574 @Callable(cl)
575575 func claimWx (at) = {
576576     let as = toString(cl.caller)
577577     let cH = invoke(this, "claimWxINTERNAL", [at, as], nil)
578578     $Tuple2(nil, cH)
579579     }
580580 
581581 
582582 
583583 @Callable(cl)
584584 func claimWxINTERNAL (at,as) = {
585585     let cp = ck(cl)
586586     if ((cp == cp))
587587         then {
588588             let aD = valueOrErrorMessage(addressFromString(as), "claimWxINTERNAL: invalid user address")
589589             let bx = y(aX, ac(at))
590590             let cI = av(at, as)
591591             let cJ = ay(at)
592592             let cK = aw(at, as)
593593             let cL = ax(at, as)
594594             let cD = D(this, cI)
595595             let cM = D(this, cK)
596596             let cN = D(this, cL)
597597             let cO = D(this, cJ)
598598             let cP = bU(at, as, bx, 0)
599599             let ce = cP._1
600600             let cA = cP._2
601601             let bT = cP._3
602602             let cF = max([(ce - cD), g])
603603             if ((g >= cF))
604604                 then throw("nothing to claim")
605605                 else {
606606                     let cQ = max([p(l(invoke(aZ, "claimWxBoost", [at, as], nil))[0]), 0])
607607                     let cR = cF
608608                     let cS = min([(cR * toBigInt(2)), toBigInt(cQ)])
609609                     let cT = (cR + cS)
610610                     let cU = t(l(invoke(aY, "emit", [toInt(cR)], nil))[0])
611611                     let cV = l(invoke(aY, "emit", [toInt(cS)], nil))
612612                     if ((cV == cV))
613613                         then {
614614                             let cW = (cD + cF)
615615                             let cX = (cM + cR)
616616                             let cY = (cM + cR)
617617                             let cZ = (cM + cR)
618618                             $Tuple2([StringEntry(cI, toString(cW)), StringEntry(cK, toString(cX)), StringEntry(cL, toString(cY)), StringEntry(cJ, toString(cZ)), ScriptTransfer(aD, toInt(cR), cU), ScriptTransfer(aD, toInt(cS), cU), aU("claim", as, at, toInt(cF), cl.transactionId)], toInt(cT))
619619                             }
620620                         else throw("Strict value is not equal to itself.")
621621                     }
622622             }
623623         else throw("Strict value is not equal to itself.")
624624     }
625625 
626626 
627627 
628628 @Callable(cl)
629629 func claimWxBulkInternalREADONLY (da,db,as,dc) = if ((da == size(db)))
630630     then $Tuple2(nil, dc)
631631     else {
632632         let aB = db[da]
633633         let dd = split({
634634             let de = invoke(this, "claimWxREADONLY", [aB, as], nil)
635635             if ($isInstanceOf(de, "String"))
636636                 then de
637637                 else throw(($getType(de) + " couldn't be cast to String"))
638638             }, e)
639639         let df = dd[3]
640640         let dg = dd[4]
641641         let dh = (dc :+ makeString(["%d%d", df, dg], e))
642642         let di = {
643643             let de = invoke(this, "claimWxBulkInternalREADONLY", [(da + 1), db, as, dh], nil)
644644             if ($isInstanceOf(de, "List[Any]"))
645645                 then de
646646                 else throw(($getType(de) + " couldn't be cast to List[Any]"))
647647             }
648648         if ((di == di))
649649             then $Tuple2(nil, di)
650650             else throw("Strict value is not equal to itself.")
651651         }
652652 
653653 
654654 
655655 @Callable(cl)
656656 func claimWxBulkREADONLY (db,as) = {
657657     let dh = invoke(this, "claimWxBulkInternalREADONLY", [0, db, as, nil], nil)
658658     $Tuple2(nil, dh)
659659     }
660660 
661661 
662662 
663663 @Callable(cl)
664664 func claimWxREADONLY (at,as) = {
665665     let bY = ar(as, at)
666666     let bz = au(at)
667667     let cI = av(at, as)
668668     let bs = az(bY)
669669     let bA = az(bz)
670670     let cD = D(this, cI)
671671     let bx = y(aX, ac(at))
672672     let bC = getIntegerValue(aX, ad(bx))
673673     let dj = C(aY, am())
674674     let bD = C(aY, ao())
675675     let dk = if ((bD > height))
676676         then 0
677677         else (height - bD)
678678     let dl = fraction((dj * dk), bC, f)
679679     let dm = fraction(dl, bs, bA)
680680     let dn = bU(at, as, bx, 0)
681681     let ce = dn._1
682682     let cA = dn._2
683683     let bT = dn._3
684684     let cF = max([(ce - cD), g])
685685     let do = l(invoke(aZ, "claimWxBoostREADONLY", [at, as], nil))
686686     let cQ = max([p(do[0]), 0])
687687     let dp = r(do[1])
688688     let cR = cF
689689     let cS = min([(cR * toBigInt(2)), toBigInt(cQ)])
690690     let cT = (cR + cS)
691691     $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", at, as, toString(cT), toString(cD), toString(cR), toString(cS), "soon"], e))
692692     }
693693 
694694 
695695 
696696 @Callable(cl)
697697 func stakedByUserREADONLY (at,as) = {
698698     let bs = valueOrElse(getInteger(ar(as, at)), 0)
699699     $Tuple2(nil, bs)
700700     }
701701 
702702 
703703 
704704 @Callable(cl)
705705 func usersListTraversal (aB) = {
706706     let cp = if ((toBase58String(cl.caller.bytes) == valueOrElse(getString(this, M()), "")))
707707         then true
708708         else cm(cl)
709709     if ((cp == cp))
710710         then {
711711             let be = bc(aB)
712712             let dq = getString(bb(aB))
713713             let bk = getString(bd(be))
714714             let n = dq
715715             if ($isInstanceOf(n, "Unit"))
716716                 then {
717717                     let dr = bk
718718                     if ($isInstanceOf(dr, "Unit"))
719719                         then $Tuple2(nil, false)
720720                         else if ($isInstanceOf(dr, "String"))
721721                             then {
722722                                 let ds = dr
723723                                 $Tuple2([StringEntry(bb(aB), ds)], true)
724724                                 }
725725                             else throw("Match error")
726726                     }
727727                 else if ($isInstanceOf(n, "String"))
728728                     then {
729729                         let aD = n
730730                         let cD = D(this, av(aB, aD))
731731                         let cE = y(aX, ac(aB))
732732                         let ce = bU(aB, aD, cE, 0)._1
733733                         let cF = (ce - cD)
734734                         let cG = if ((cF > g))
735735                             then invoke(this, "claimWxINTERNAL", [aB, aD], nil)
736736                             else unit
737737                         if ((cG == cG))
738738                             then {
739739                                 let dt = getString(bi(be, aD))
740740                                 let dr = dt
741741                                 if ($isInstanceOf(dr, "Unit"))
742742                                     then $Tuple2([DeleteEntry(bb(aB))], false)
743743                                     else if ($isInstanceOf(dr, "String"))
744744                                         then {
745745                                             let du = dr
746746                                             $Tuple2([StringEntry(bb(aB), du)], true)
747747                                             }
748748                                         else throw("Match error")
749749                                 }
750750                             else throw("Strict value is not equal to itself.")
751751                         }
752752                     else throw("Match error")
753753             }
754754         else throw("Strict value is not equal to itself.")
755755     }
756756 
757757 
758758 
759759 @Callable(cl)
760760 func onModifyWeight (at,bx) = if ((cl.caller != aX))
761761     then throw("permissions denied")
762762     else {
763763         let dv = bw(at, bx, 0)
764764         let bu = dv._1
765765         let bW = dv._2
766766         let bX = dv._3
767767         bW
768768         }
769769 
770770 
771771 @Verifier(dw)
772772 func dx () = {
773773     let dy = {
774774         let n = ch()
775775         if ($isInstanceOf(n, "ByteVector"))
776776             then {
777777                 let cn = n
778778                 cn
779779                 }
780780             else if ($isInstanceOf(n, "Unit"))
781781                 then dw.senderPublicKey
782782                 else throw("Match error")
783783         }
784784     sigVerify(dw.bodyBytes, dw.proofs[0], dy)
785785     }
786786 
github/deemru/w8io/fabc49c 
86.71 ms ◑