tx · D4TvE6wrGJ1fCKzpsycU3BmqoCnUWFGxxQV8dFAMHk2C

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.03000000 Waves

2022.07.06 10:03 [2127500] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "D4TvE6wrGJ1fCKzpsycU3BmqoCnUWFGxxQV8dFAMHk2C",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1657090973508,
    "version": 1,
    "sender": "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz",
    "senderPublicKey": "D28XoueZWsMfm8Y5pa6C5ZFuYoWgre2Wm8tzJANJgMnq",
    "proofs": [
        "2hbN5aVtP5Zed2U5romiSWZ6dx9HqVuwTWfs5FCn5DKF8SzoZD7vgjB4RjG2tjWa5P8L9GoCPCpJwQz9n3osTaR1"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2127500,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: DzCJD4RMASq1oYbpTWXMwzaHtdU8Bb4KxnmYw6AcbP2v
Next: 7JCo7swMDbdFctSmx5skD48mSCbQyMdYuoLNjne39Gwa

Diff: 

OldNewDifferences
708708                         let cy = A(this, ar(ax, az))
709709                         let cz = v(aT, Y(ax))
710710                         let bZ = bP(ax, az, cz, 0)._1
711-                        let cA = (bZ - cy)
711+                        let cA = max([(bZ - cy), g])
712712                         let cB = if ((cA > g))
713713                             then invoke(this, "claimWxINTERNAL", [ax, az], nil)
714714                             else unit

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