tx · EBzqmd3VceqSzZUj3QE4kRbTSB61VZvns1KnPh9xDP8o

3NCBhUuq2LX5fqkbvsQ5LPHtCkt3B9T2Q8j:  -0.02200000 Waves

2023.03.13 15:56 [2488280] smart account 3NCBhUuq2LX5fqkbvsQ5LPHtCkt3B9T2Q8j > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EBzqmd3VceqSzZUj3QE4kRbTSB61VZvns1KnPh9xDP8o",
    "fee": 2200000,
    "feeAssetId": null,
    "timestamp": 1678712287332,
    "version": 2,
    "chainId": 84,
    "sender": "3NCBhUuq2LX5fqkbvsQ5LPHtCkt3B9T2Q8j",
    "senderPublicKey": "DC4RRwQbHG5vzo62QQXx7F4TqWREogNeJ8dk97jHNGcp",
    "proofs": [
        "4cjenk1xzkZ25qXZrQ7acDW7BvnMdnXoAQqGQwidv6kB7buASTKFfStrdkxFP7xriaLzZ7dFk85jqG7tfXMpzjWu"
    ],
    "script": "base64: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",
    "height": 2488280,
    "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 = 1
7+
8+let c = 100000000
9+
10+let d = (1 * c)
11+
12+let e = (1000 * c)
13+
14+let f = 86400000
15+
16+func g (h) = fraction(c, 365, h)
17+
18+
19+let i = (1000000 * c)
20+
21+let j = fraction(c, 10, 100)
22+
23+let k = "Current_PercentageReduction_Factor_For_Mr"
24+
25+let l = "Minting_Rate"
26+
27+let m = "Staw_AssetId"
28+
29+let n = "manager"
30+
31+let o = "Dfx"
32+
33+let p = "CirculationIncrementIndex"
34+
35+let q = "LeaseNode"
36+
37+let r = "EmissionAmountClaimed"
38+
39+let s = "CanClaimEmissionAmount"
40+
41+let t = "WalletAddress"
42+
43+let u = "TotalEntryIndexCount"
44+
45+let v = "TotalLocked"
46+
47+let w = "LockDuration"
48+
49+let x = "GlobalLockIndex"
50+
51+let y = "LockIdentifier"
52+
53+let z = "AmountInWaves"
54+
55+let A = "AmountInStaw"
56+
57+let B = "AmountInStawLP"
58+
59+let C = "TXID"
60+
61+let D = "LockAtHeight"
62+
63+let E = "LocKPeriodInMilliSec"
64+
65+let F = "TotalWavesClaimed"
66+
67+let G = "LeaseState"
68+
69+let H = "TotalStawMinted"
70+
71+let I = "TotalWavesLocked"
72+
73+let J = "TotalStawLP"
74+
75+let K = "IndexCount"
76+
77+func L (M) = getInteger(this, M)
78+
79+
80+func N (M) = getString(this, M)
81+
82+
83+func O (M) = getBoolean(this, M)
84+
85+
86+func P (M) = value(getBoolean(this, M))
87+
88+
89+func Q (M) = value(getInteger(this, M))
90+
91+
92+func R (M) = value(getString(this, M))
93+
94+
95+func S (M,T) = {
96+    let U = T
97+    if ($isInstanceOf(U, "String"))
98+        then {
99+            let T = U
100+            if (isDefined(N(M)))
101+                then R(M)
102+                else T
103+            }
104+        else if ($isInstanceOf(U, "Int"))
105+            then {
106+                let T = U
107+                if (isDefined(L(M)))
108+                    then Q(M)
109+                    else T
110+                }
111+            else if ($isInstanceOf(U, "Boolean"))
112+                then {
113+                    let T = U
114+                    if (isDefined(O(M)))
115+                        then P(M)
116+                        else T
117+                    }
118+                else throw(("value type not supported for " + M))
119+    }
120+
121+
122+func V (W,X) = {
123+    let U = W
124+    if ($isInstanceOf(U, "String"))
125+        then {
126+            let W = U
127+            W
128+            }
129+        else throw(X)
130+    }
131+
132+
133+func Y (W,X) = {
134+    let U = W
135+    if ($isInstanceOf(U, "Int"))
136+        then {
137+            let W = U
138+            W
139+            }
140+        else throw(X)
141+    }
142+
143+
144+func Z (W,X) = {
145+    let U = W
146+    if ($isInstanceOf(U, "Boolean"))
147+        then {
148+            let W = U
149+            W
150+            }
151+        else throw(X)
152+    }
153+
154+
155+func aa (M,ab) = if ((0 > ab))
156+    then throw(((("writing negative value " + toString(ab)) + " for key ") + M))
157+    else IntegerEntry(M, ab)
158+
159+
160+func ac (M,ab) = if ((" " == ab))
161+    then throw(("writing an empty string " + ab))
162+    else StringEntry(M, ab)
163+
164+
165+func ad (ae,X) = if (ae)
166+    then throw(X)
167+    else true
168+
169+
170+func af (M,ag) = {
171+    let U = ag
172+    if ($isInstanceOf(U, "Int"))
173+        then {
174+            let ag = U
175+            aa(M, ag)
176+            }
177+        else if ($isInstanceOf(U, "String"))
178+            then {
179+                let ag = U
180+                ac(M, ag)
181+                }
182+            else if ($isInstanceOf(U, "Boolean"))
183+                then {
184+                    let ag = U
185+                    BooleanEntry(M, ag)
186+                    }
187+                else throw("type not supported")
188+    }
189+
190+
191+func ah (ai) = {
192+    let aj = ad((ai >= 0), "invalid locking days!")
193+    if ((aj == aj))
194+        then (ai * f)
195+        else throw("Strict value is not equal to itself.")
196+    }
197+
198+
199+func ak (M,ab) = if (!(isDefined(N(M))))
200+    then ac(M, ab)
201+    else throw(("entry already initialized: " + M))
202+
203+
204+func al (M,ab) = if (!(isDefined(N(M))))
205+    then aa(M, ab)
206+    else throw((" entry already initialized: " + M))
207+
208+
209+func am (an) = {
210+    let ao = V(N(n), "manager not found")
211+    if ((ao == ao))
212+        then ad((toBase58String(an.caller.bytes) != ao), "address not authorized")
213+        else throw("Strict value is not equal to itself.")
214+    }
215+
216+
217+func ap (W) = if ((0 > W))
218+    then -(W)
219+    else W
220+
221+
222+func aq (ar) = {
223+    let U = ar
224+    if ($isInstanceOf(U, "String"))
225+        then {
226+            let ar = U
227+            let as = addressFromString(ar)
228+            let at = as
229+            if ($isInstanceOf(at, "Address"))
230+                then {
231+                    let as = at
232+                    true
233+                    }
234+                else throw("invalid address")
235+            }
236+        else if ($isInstanceOf(U, "ByteVector"))
237+            then {
238+                let ar = U
239+                let as = addressFromPublicKey(ar)
240+                let at = as
241+                if ($isInstanceOf(at, "Address"))
242+                    then {
243+                        let as = at
244+                        true
245+                        }
246+                    else throw("invalid public key")
247+                }
248+            else throw("invalid input type")
249+    }
250+
251+
252+func au () = {
253+    let av = Y(L(p), "increment index not previously defined")
254+    if ((av == av))
255+        then {
256+            let aw = V(N(m), "asset id not previouly defined")
257+            if ((aw == aw))
258+                then {
259+                    let ax = {
260+                        let U = assetInfo(fromBase58String(aw))
261+                        if ($isInstanceOf(U, "Asset"))
262+                            then {
263+                                let ay = U
264+                                ay.quantity
265+                                }
266+                            else throw(("asset not found for " + aw))
267+                        }
268+                    let az = (ap((ax - i)) / i)
269+                    let aA = if ((az > av))
270+                        then (az + av)
271+                        else av
272+                    let aB = Y(l, "miniting rate not previously defined")
273+                    if ((aA == av))
274+                        then aB
275+                        else {
276+                            let aC = (Y(k, "reduction factor not previously defined") + 10)
277+                            let aD = (aB - fraction(aB, aC, 100))
278+                            let aE = aa(l, aD)
279+                            if ((aE == aE))
280+                                then {
281+                                    let aF = aa(k, aC)
282+                                    if ((aF == aF))
283+                                        then {
284+                                            let aG = aa(p, aA)
285+                                            if ((aG == aG))
286+                                                then aD
287+                                                else throw("Strict value is not equal to itself.")
288+                                            }
289+                                        else throw("Strict value is not equal to itself.")
290+                                    }
291+                                else throw("Strict value is not equal to itself.")
292+                            }
293+                    }
294+                else throw("Strict value is not equal to itself.")
295+            }
296+        else throw("Strict value is not equal to itself.")
297+    }
298+
299+
300+func aH (M) = {
301+    let aI = V(N(M), "entry not found")
302+    if ((aI == aI))
303+        then {
304+            let aJ = split(aI, a)
305+            let aK = takeRight(aJ[0], 1)
306+            let aL = aJ[(size(aJ) - 1)]
307+            let ag = if ((aK == "s"))
308+                then aL
309+                else if ((aK == "d"))
310+                    then parseIntValue(aL)
311+                    else if ((aK == "b"))
312+                        then fromBase58String(aL)
313+                        else throw(("could not parse registry value for " + M))
314+            ag
315+            }
316+        else throw("Strict value is not equal to itself.")
317+    }
318+
319+
320+func aM (aN,aO,aP,aQ) = {
321+    let aR = (Y(L(I), "global waves sum not previously defined") + aN)
322+    let aS = (Y(L(H), "gobal staw minted not previously defined") + aO)
323+    let aT = (Y(L(J), "global stawPL not previously defined") + aP)
324+    let aU = (Y(L(K), "global index count not previously defined") + aQ)
325+[aa(I, aR), aa(H, aS), aa(J, aT), aa(K, aU)]
326+    }
327+
328+
329+func aV (aW,aX,aY,aZ,ba,aN,aO,bb,bc,bd,be,bf,bg) = {
330+    let bh = makeString([aX, aW, C], a)
331+    let bi = makeString([aX, aW, w], a)
332+    let bj = makeString([aX, aW, x], a)
333+    let bk = makeString([aX, aW, z], a)
334+    let bl = makeString([aX, aW, A], a)
335+    let bm = makeString([aX, aW, B], a)
336+    let bn = makeString([aX, aW, D], a)
337+    let bo = makeString([aX, aW, y], a)
338+    let bp = makeString([aX, v], a)
339+    let bq = makeString([aX, u], a)
340+    let br = makeString([aX, aW, E], a)
341+    let bs = makeString([aX, aW, F], a)
342+    let bt = makeString([aX, aW, G], a)
343+    let bu = makeString(["%s", aW], a)
344+    let bv = makeString(["%d", toString(aY)], a)
345+    let bw = makeString(["%d", toString(ba)], a)
346+    let bx = makeString(["%d", toString(aN)], a)
347+    let by = makeString(["%d", toString(aO)], a)
348+    let bz = makeString(["%d", toString(bb)], a)
349+    let bA = makeString(["%d", toString(bc)], a)
350+    let bB = makeString(["%b", bd], a)
351+    let bC = makeString(["%d", toString(be)], a)
352+    let bD = makeString(["%d", toString(bf)], a)
353+    let bE = makeString(["%d", toString(aZ)], a)
354+    let bF = makeString(["%d", toString(0)], a)
355+    let bG = makeString(["%s", bg], a)
356+[ak(bh, bu), ak(bj, bw), ac(bq, bD), ac(bp, bC), ak(bi, bv), ak(br, bE), ak(bk, bx), ak(bl, by), ac(bm, bz), ac(bs, bF), ak(bn, bA), ak(bo, bB), ac(bt, bG)]
357+    }
358+
359+
360+func bH (h,bI) = {
361+    let bJ = au()
362+    (fraction(c, (f * bJ), g(h)) * bI)
363+    }
364+
365+
366+func bK (h,bL) = {
367+    let bM = fraction(h, 15, 10)
368+    ((bL / ((h * bM) - h)) * f)
369+    }
370+
371+
372+func bN (bO) = {
373+    let bP = Y(L(J), "could not get the running StawLP")
374+[aa(J, (bP + bO))]
375+    }
376+
377+
378+func bQ (bO) = {
379+    let bP = Y(L(J), "could not get the running StawLP")
380+[aa(J, (bP - bO))]
381+    }
382+
383+
384+func bR (bO) = {
385+    let bS = Y(L(I), "could not get total locked waves")
386+[aa(I, (bS + bO))]
387+    }
388+
389+
390+func bT (bO) = {
391+    let bS = Y(L(I), "could not get total locked waves")
392+[aa(I, (bS - bO))]
393+    }
394+
395+
396+func bU (bV) = {
397+    let bW = {
398+        let U = blockInfoByHeight(bV)
399+        if ($isInstanceOf(U, "BlockInfo"))
400+            then {
401+                let bX = U
402+                bX.timestamp
403+                }
404+            else throw("counld get timestamp")
405+        }
406+    bW
407+    }
408+
409+
410+func bY () = true
411+
412+
413+func bZ () = true
414+
415+
416+func ca () = true
417+
418+
419+func cb () = true
420+
421+
422+@Callable(an)
423+func getEmission (h,bL) = {
424+    let cc = am(an)
425+    if ((cc == cc))
426+        then $Tuple2(nil, bK(h, bL))
427+        else throw("Strict value is not equal to itself.")
428+    }
429+
430+
431+
432+@Callable(an)
433+func init (ao,cd,ce,cf) = {
434+    let cc = aq(ao)
435+    if ((cc == cc))
436+        then {
437+            let cg = aq(cd)
438+            if ((cg == cg))
439+                then {
440+                    let ch = aq(cf)
441+                    if ((ch == ch))
442+                        then {
443+                            let ci = S(p, 0)
444+                            let cj = S(k, 0)
445+                            let ck = S(l, c)
446+                            let cl = S(H, 0)
447+                            let cm = S(J, 0)
448+                            let cn = S(K, 0)
449+                            let co = S(I, 0)
450+[ak(n, ao), ak(o, cd), ak(m, ce), ac(q, cf), af(p, ci), af(l, ck), af(k, cj), af(I, co)]
451+                            }
452+                        else throw("Strict value is not equal to itself.")
453+                    }
454+                else throw("Strict value is not equal to itself.")
455+            }
456+        else throw("Strict value is not equal to itself.")
457+    }
458+
459+
460+
461+@Callable(an)
462+func modifyInternalParams (M) = {
463+    let cc = am(an)
464+    if ((cc == cc))
465+        then nil
466+        else throw("Strict value is not equal to itself.")
467+    }
468+
469+
470+
471+@Callable(an)
472+func revokeMint () = {
473+    let cc = am(an)
474+    if ((cc == cc))
475+        then nil
476+        else throw("Strict value is not equal to itself.")
477+    }
478+
479+
480+
481+@Callable(an)
482+func claim (aW) = {
483+    let cp = toBase58String(an.caller.bytes)
484+    let cq = makeString([cp, aW, z], a)
485+    let cr = makeString([cp, aW, w], a)
486+    let cs = makeString([cp, aW, y], a)
487+    let ct = makeString([cp, aW, E], a)
488+    let cu = makeString([cp, aW, F], a)
489+    let cv = makeString([cp, aW, B], a)
490+    let cw = makeString([cp, aW, z], a)
491+    let cx = makeString([cp, v], a)
492+    let cy = makeString([cp, aW, G], a)
493+    let cz = makeString([cp, aW, G], a)
494+    let cA = Q(I)
495+    if ((cA == cA))
496+        then {
497+            let cB = Q(J)
498+            if ((cB == cB))
499+                then {
500+                    let bd = {
501+                        let U = aH(cs)
502+                        if ($isInstanceOf(U, "ByteVector"))
503+                            then {
504+                                let cC = U
505+                                cC
506+                                }
507+                            else throw("failed to get lease id")
508+                        }
509+                    if ((bd == bd))
510+                        then {
511+                            let cD = {
512+                                let U = aH(cx)
513+                                if ($isInstanceOf(U, "Int"))
514+                                    then {
515+                                        let cC = U
516+                                        cC
517+                                        }
518+                                    else throw("failed to get total waves locked by this address")
519+                                }
520+                            if ((cD == cD))
521+                                then {
522+                                    let aN = {
523+                                        let U = aH(cw)
524+                                        if ($isInstanceOf(U, "Int"))
525+                                            then {
526+                                                let cC = U
527+                                                cC
528+                                                }
529+                                            else throw("failed to get total waves locked")
530+                                        }
531+                                    if ((aN == aN))
532+                                        then {
533+                                            let cE = {
534+                                                let U = aH(cu)
535+                                                if ($isInstanceOf(U, "Int"))
536+                                                    then {
537+                                                        let cC = U
538+                                                        cC
539+                                                        }
540+                                                    else throw("failed to get total waves claimed")
541+                                                }
542+                                            if ((cE == cE))
543+                                                then {
544+                                                    let bb = {
545+                                                        let U = aH(cv)
546+                                                        if ($isInstanceOf(U, "Int"))
547+                                                            then {
548+                                                                let cC = U
549+                                                                cC
550+                                                                }
551+                                                            else throw("failed to get stawPL")
552+                                                        }
553+                                                    if ((bb == bb))
554+                                                        then {
555+                                                            let cF = {
556+                                                                let U = aH(ct)
557+                                                                if ($isInstanceOf(U, "Int"))
558+                                                                    then {
559+                                                                        let cC = U
560+                                                                        cC
561+                                                                        }
562+                                                                    else throw("failed to get lock period timespam")
563+                                                                }
564+                                                            if ((cF == cF))
565+                                                                then {
566+                                                                    let cG = {
567+                                                                        let U = bU(height)
568+                                                                        if ($isInstanceOf(U, "Int"))
569+                                                                            then {
570+                                                                                let cC = U
571+                                                                                cC
572+                                                                                }
573+                                                                            else throw("failed to get current timestamp")
574+                                                                        }
575+                                                                    if ((cG == cG))
576+                                                                        then {
577+                                                                            let bL = {
578+                                                                                let U = aH(cq)
579+                                                                                if ($isInstanceOf(U, "Int"))
580+                                                                                    then {
581+                                                                                        let cC = U
582+                                                                                        cC
583+                                                                                        }
584+                                                                                    else throw("failed to get collateral")
585+                                                                                }
586+                                                                            if ((bL == bL))
587+                                                                                then {
588+                                                                                    let h = {
589+                                                                                        let U = aH(cr)
590+                                                                                        if ($isInstanceOf(U, "Int"))
591+                                                                                            then {
592+                                                                                                let cC = U
593+                                                                                                cC
594+                                                                                                }
595+                                                                                            else throw("failed to get lockPeriod")
596+                                                                                        }
597+                                                                                    if ((h == h))
598+                                                                                        then {
599+                                                                                            let cH = {
600+                                                                                                let U = aH(cy)
601+                                                                                                if ($isInstanceOf(U, "String"))
602+                                                                                                    then {
603+                                                                                                        let cC = U
604+                                                                                                        cC
605+                                                                                                        }
606+                                                                                                    else throw("failed to get lease state")
607+                                                                                                }
608+                                                                                            if ((cH == cH))
609+                                                                                                then {
610+                                                                                                    let bg = {
611+                                                                                                        let U = aH(cz)
612+                                                                                                        if ($isInstanceOf(U, "String"))
613+                                                                                                            then {
614+                                                                                                                let cC = U
615+                                                                                                                cC
616+                                                                                                                }
617+                                                                                                            else throw("failed to get lease state for user")
618+                                                                                                        }
619+                                                                                                    if ((bg == bg))
620+                                                                                                        then {
621+                                                                                                            let cc = ad((cF > cG), "lock period for this entry has not elapsed")
622+                                                                                                            if ((cc == cc))
623+                                                                                                                then {
624+                                                                                                                    let cI = if ((cH == "leased"))
625+                                                                                                                        then $Tuple2(LeaseCancel(bd), ac(cy, "cancelled"))
626+                                                                                                                        else $Tuple2(ac(cy, "cancelled"), ac(cy, "cancelled"))
627+                                                                                                                    if ((cI == cI))
628+                                                                                                                        then {
629+                                                                                                                            let cg = ad(if ((0 == aN))
630+                                                                                                                                then true
631+                                                                                                                                else (0 == bb), "all claims exhausted for this trx")
632+                                                                                                                            if ((cg == cg))
633+                                                                                                                                then {
634+                                                                                                                                    let cJ = (bK(h, bL) * f)
635+                                                                                                                                    let cK = {
636+                                                                                                                                        let cL = (cG - cF)
637+                                                                                                                                        let cM = (cL / f)
638+                                                                                                                                        if ((cM == 0))
639+                                                                                                                                            then throw("less than 24hrs before first claim")
640+                                                                                                                                            else if (((cL % f) != 0))
641+                                                                                                                                                then throw("already claimed or less than 24hrs before next claim")
642+                                                                                                                                                else if ((cM > h))
643+                                                                                                                                                    then throw("all claims exhausted")
644+                                                                                                                                                    else {
645+                                                                                                                                                        let cN = (cM * cJ)
646+                                                                                                                                                        let cO = ad((cN == cE), "can only claim once in 24hrs")
647+                                                                                                                                                        if ((cO == cO))
648+                                                                                                                                                            then {
649+                                                                                                                                                                let cP = ad(((cN + cE) > aN), "all claims exhausted")
650+                                                                                                                                                                if ((cP == cP))
651+                                                                                                                                                                    then {
652+                                                                                                                                                                        let cQ = if ((cM == 1))
653+                                                                                                                                                                            then cN
654+                                                                                                                                                                            else (cN - cE)
655+                                                                                                                                                                        let cR = cN
656+                                                                                                                                                                        let cS = if ((cM == 1))
657+                                                                                                                                                                            then (aN - cN)
658+                                                                                                                                                                            else (aN - (cN - cE))
659+                                                                                                                                                                        let cT = if ((cM == 1))
660+                                                                                                                                                                            then (bb - cN)
661+                                                                                                                                                                            else (bb - (cN - cE))
662+                                                                                                                                                                        let cU = (cA - cS)
663+                                                                                                                                                                        let cV = (cB - cT)
664+                                                                                                                                                                        let cW = (cD - cQ)
665+                                                                                                                                                                        let bx = makeString(["%d", toString(cS)], a)
666+                                                                                                                                                                        let bz = makeString(["%d", toString(cT)], a)
667+                                                                                                                                                                        let bF = makeString(["%d", toString(cR)], a)
668+                                                                                                                                                                        let cX = makeString(["%d", toString(cW)], a)
669+[cI._1, cI._2, ac(cw, bx), ac(cv, bz), ac(cu, bF), ac(cx, cX), aa(I, cU), aa(J, cV), ScriptTransfer(Address(an.caller.bytes), cQ, unit)]
670+                                                                                                                                                                        }
671+                                                                                                                                                                    else throw("Strict value is not equal to itself.")
672+                                                                                                                                                                }
673+                                                                                                                                                            else throw("Strict value is not equal to itself.")
674+                                                                                                                                                        }
675+                                                                                                                                        }
676+                                                                                                                                    if ((cK == cK))
677+                                                                                                                                        then cK
678+                                                                                                                                        else throw("Strict value is not equal to itself.")
679+                                                                                                                                    }
680+                                                                                                                                else throw("Strict value is not equal to itself.")
681+                                                                                                                            }
682+                                                                                                                        else throw("Strict value is not equal to itself.")
683+                                                                                                                    }
684+                                                                                                                else throw("Strict value is not equal to itself.")
685+                                                                                                            }
686+                                                                                                        else throw("Strict value is not equal to itself.")
687+                                                                                                    }
688+                                                                                                else throw("Strict value is not equal to itself.")
689+                                                                                            }
690+                                                                                        else throw("Strict value is not equal to itself.")
691+                                                                                    }
692+                                                                                else throw("Strict value is not equal to itself.")
693+                                                                            }
694+                                                                        else throw("Strict value is not equal to itself.")
695+                                                                    }
696+                                                                else throw("Strict value is not equal to itself.")
697+                                                            }
698+                                                        else throw("Strict value is not equal to itself.")
699+                                                    }
700+                                                else throw("Strict value is not equal to itself.")
701+                                            }
702+                                        else throw("Strict value is not equal to itself.")
703+                                    }
704+                                else throw("Strict value is not equal to itself.")
705+                            }
706+                        else throw("Strict value is not equal to itself.")
707+                    }
708+                else throw("Strict value is not equal to itself.")
709+            }
710+        else throw("Strict value is not equal to itself.")
711+    }
712+
713+
714+
715+@Callable(an)
716+func mintStaw (h) = {
717+    let cp = toBase58String(an.caller.bytes)
718+    let cY = toBase58String(an.transactionId)
719+    let cc = ad((1 != size(an.payments)), "no payments attached")
720+    if ((cc == cc))
721+        then {
722+            let cg = if (isDefined(an.payments[0].assetId))
723+                then throw("only waves supported")
724+                else true
725+            if ((cg == cg))
726+                then {
727+                    let cZ = an.payments[0].amount
728+                    let ch = if (if ((d > cZ))
729+                        then true
730+                        else (cZ > e))
731+                        then throw("amount to lock is out of range")
732+                        else true
733+                    if ((ch == ch))
734+                        then {
735+                            let da = if ((b > h))
736+                                then throw("minimum of 14 days lock period")
737+                                else true
738+                            if ((da == da))
739+                                then {
740+                                    let db = bH(h, cZ)
741+                                    let aP = cZ
742+                                    let dc = fraction(db, 10, 100)
743+                                    let dd = (db - dc)
744+                                    let de = (bU(height) + ah(h))
745+                                    if ((de == de))
746+                                        then {
747+                                            let df = (Y(L(K), "global index not previously defined") + 1)
748+                                            if ((df == df))
749+                                                then {
750+                                                    let dg = Address(fromBase58String(V(N(o), "dfx not previously defined")))
751+                                                    if ((dg == dg))
752+                                                        then {
753+                                                            let aw = fromBase58String(V(N(m), "asset id not previously defined"))
754+                                                            if ((aw == aw))
755+                                                                then {
756+                                                                    let dh = Address(fromBase58String(V(N(q), "lease node not previously defined")))
757+                                                                    if ((dh == dh))
758+                                                                        then {
759+                                                                            let di = makeString([cp, u], a)
760+                                                                            let dj = makeString([cp, v], a)
761+                                                                            let dk = {
762+                                                                                let U = aH(di)
763+                                                                                if ($isInstanceOf(U, "Int"))
764+                                                                                    then {
765+                                                                                        let aJ = U
766+                                                                                        (aJ + 1)
767+                                                                                        }
768+                                                                                    else 0
769+                                                                                }
770+                                                                            if ((dk == dk))
771+                                                                                then {
772+                                                                                    let dl = {
773+                                                                                        let U = aH(dj)
774+                                                                                        if ($isInstanceOf(U, "Int"))
775+                                                                                            then {
776+                                                                                                let aJ = U
777+                                                                                                (aJ + cZ)
778+                                                                                                }
779+                                                                                            else cZ
780+                                                                                        }
781+                                                                                    if ((dl == dl))
782+                                                                                        then {
783+                                                                                            let dm = Lease(dh, cZ)
784+                                                                                            if ((dm == dm))
785+                                                                                                then {
786+                                                                                                    let dn = toBase58String(calculateLeaseId(dm))
787+                                                                                                    if ((dn == dn))
788+                                                                                                        then (([dm, ScriptTransfer(dg, dc, aw), ScriptTransfer(Address(an.caller.bytes), dd, aw)] ++ aV(cY, cp, h, de, df, cZ, dd, aP, height, dn, dl, dk, "leased")) ++ aM(cZ, db, aP, df))
789+                                                                                                        else throw("Strict value is not equal to itself.")
790+                                                                                                    }
791+                                                                                                else throw("Strict value is not equal to itself.")
792+                                                                                            }
793+                                                                                        else throw("Strict value is not equal to itself.")
794+                                                                                    }
795+                                                                                else throw("Strict value is not equal to itself.")
796+                                                                            }
797+                                                                        else throw("Strict value is not equal to itself.")
798+                                                                    }
799+                                                                else throw("Strict value is not equal to itself.")
800+                                                            }
801+                                                        else throw("Strict value is not equal to itself.")
802+                                                    }
803+                                                else throw("Strict value is not equal to itself.")
804+                                            }
805+                                        else throw("Strict value is not equal to itself.")
806+                                    }
807+                                else throw("Strict value is not equal to itself.")
808+                            }
809+                        else throw("Strict value is not equal to itself.")
810+                    }
811+                else throw("Strict value is not equal to itself.")
812+            }
813+        else throw("Strict value is not equal to itself.")
814+    }
815+
816+
817+@Verifier(do)
818+func dp () = {
819+    let U = do
820+    if ($isInstanceOf(U, "TransferTransaction"))
821+        then {
822+            let dq = U
823+            if ((100 > dq.amount))
824+                then sigVerify(dq.bodyBytes, dq.proofs[0], dq.senderPublicKey)
825+                else false
826+            }
827+        else false
828+    }
829+
github/deemru/w8io/169f3d6 
43.79 ms ◑