tx · CEAU4AETXpN3kKocb6qY3BTECyLTM9JC17jHvzNbSvhf

3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH:  -0.02300000 Waves

2023.03.14 21:15 [2490073] smart account 3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CEAU4AETXpN3kKocb6qY3BTECyLTM9JC17jHvzNbSvhf",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1678817797737,
    "version": 2,
    "chainId": 84,
    "sender": "3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH",
    "senderPublicKey": "5JqBVJpMCyD7dJLJttqYjL6CmJc4zahBHSFjFb7qQTga",
    "proofs": [
        "36JPfrhMJDYLfdkvC95uDDVudkSAVTT7MCwvynjf5MFhNrFbRHrv5rf7KL7V1ZjBEgwY7t311Y5EdjdgJ3PAQ5vN"
    ],
    "script": "base64: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",
    "height": 2490073,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: BrD3yKLCRSTm1M2QvaYNxdP5oXiDN4K79ZVw6yghUNrx

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+            let ah = makeString(["%d", toString(ag)], a)
176+            ac(M, ah)
177+            }
178+        else if ($isInstanceOf(U, "String"))
179+            then {
180+                let ag = U
181+                let ah = makeString(["%s", ag], a)
182+                ac(M, ah)
183+                }
184+            else if ($isInstanceOf(U, "Boolean"))
185+                then {
186+                    let ag = U
187+                    let ah = makeString(["%b", toString(ag)], a)
188+                    ac(M, ah)
189+                    }
190+                else throw("type not supported")
191+    }
192+
193+
194+func ai (aj) = {
195+    let ak = ad((aj >= 0), "invalid locking days!")
196+    if ((ak == ak))
197+        then (aj * f)
198+        else throw("Strict value is not equal to itself.")
199+    }
200+
201+
202+func al (M,ab) = if (!(isDefined(N(M))))
203+    then ac(M, ab)
204+    else throw(("entry already initialized: " + M))
205+
206+
207+func am (M,ab) = if (!(isDefined(N(M))))
208+    then aa(M, ab)
209+    else throw((" entry already initialized: " + M))
210+
211+
212+func an (ao) = {
213+    let ap = V(N(n), "manager not found")
214+    if ((ap == ap))
215+        then ad((toBase58String(ao.caller.bytes) != ap), "address not authorized")
216+        else throw("Strict value is not equal to itself.")
217+    }
218+
219+
220+func aq (W) = if ((0 > W))
221+    then -(W)
222+    else W
223+
224+
225+func ar (as) = {
226+    let U = as
227+    if ($isInstanceOf(U, "String"))
228+        then {
229+            let as = U
230+            let at = addressFromString(as)
231+            let au = at
232+            if ($isInstanceOf(au, "Address"))
233+                then {
234+                    let at = au
235+                    true
236+                    }
237+                else throw("invalid address")
238+            }
239+        else if ($isInstanceOf(U, "ByteVector"))
240+            then {
241+                let as = U
242+                let at = addressFromPublicKey(as)
243+                let au = at
244+                if ($isInstanceOf(au, "Address"))
245+                    then {
246+                        let at = au
247+                        true
248+                        }
249+                    else throw("invalid public key")
250+                }
251+            else throw("invalid input type")
252+    }
253+
254+
255+func av () = {
256+    let aw = Y(L(p), "increment index not previously defined")
257+    if ((aw == aw))
258+        then {
259+            let ax = V(N(m), "asset id not previouly defined")
260+            if ((ax == ax))
261+                then {
262+                    let ay = {
263+                        let U = assetInfo(fromBase58String(ax))
264+                        if ($isInstanceOf(U, "Asset"))
265+                            then {
266+                                let az = U
267+                                az.quantity
268+                                }
269+                            else throw(("asset not found for " + ax))
270+                        }
271+                    let aA = (aq((ay - i)) / i)
272+                    let aB = if ((aA > aw))
273+                        then (aA + aw)
274+                        else aw
275+                    let aC = Y(l, "miniting rate not previously defined")
276+                    if ((aB == aw))
277+                        then aC
278+                        else {
279+                            let aD = (Y(k, "reduction factor not previously defined") + 10)
280+                            let aE = (aC - fraction(aC, aD, 100))
281+                            let aF = aa(l, aE)
282+                            if ((aF == aF))
283+                                then {
284+                                    let aG = aa(k, aD)
285+                                    if ((aG == aG))
286+                                        then {
287+                                            let aH = aa(p, aB)
288+                                            if ((aH == aH))
289+                                                then aE
290+                                                else throw("Strict value is not equal to itself.")
291+                                            }
292+                                        else throw("Strict value is not equal to itself.")
293+                                    }
294+                                else throw("Strict value is not equal to itself.")
295+                            }
296+                    }
297+                else throw("Strict value is not equal to itself.")
298+            }
299+        else throw("Strict value is not equal to itself.")
300+    }
301+
302+
303+func aI (M) = {
304+    let aJ = V(N(M), "entry not found")
305+    if ((aJ == aJ))
306+        then {
307+            let aK = split(aJ, a)
308+            let aL = takeRight(aK[0], 1)
309+            let aM = aK[(size(aK) - 1)]
310+            let ag = if ((aL == "s"))
311+                then aM
312+                else if ((aL == "d"))
313+                    then parseIntValue(aM)
314+                    else if ((aL == "b"))
315+                        then fromBase58String(aM)
316+                        else throw(("could not parse registry value for " + M))
317+            ag
318+            }
319+        else throw("Strict value is not equal to itself.")
320+    }
321+
322+
323+func aN (aO,aP,aQ,aR) = {
324+    let aS = (Y(L(I), "global waves sum not previously defined") + aO)
325+    let aT = (Y(L(H), "gobal staw minted not previously defined") + aP)
326+    let aU = (Y(L(J), "global stawPL not previously defined") + aQ)
327+    let aV = (Y(L(K), "global index count not previously defined") + aR)
328+[aa(I, aS), aa(H, aT), aa(J, aU), aa(K, aV)]
329+    }
330+
331+
332+func aW (aX,aY,aZ,ba,bb,aO,aP,bc,bd,be,bf,bg,bh) = {
333+    let bi = makeString([aY, aX, C], a)
334+    let bj = makeString([aY, aX, w], a)
335+    let bk = makeString([aY, aX, x], a)
336+    let bl = makeString([aY, aX, z], a)
337+    let bm = makeString([aY, aX, A], a)
338+    let bn = makeString([aY, aX, B], a)
339+    let bo = makeString([aY, aX, D], a)
340+    let bp = makeString([aY, aX, y], a)
341+    let bq = makeString([aY, v], a)
342+    let br = makeString([aY, u], a)
343+    let bs = makeString([aY, aX, E], a)
344+    let bt = makeString([aY, aX, F], a)
345+    let bu = makeString([aY, aX, G], a)
346+    let bv = makeString(["%s", aX], a)
347+    let bw = makeString(["%d", toString(aZ)], a)
348+    let bx = makeString(["%d", toString(bb)], a)
349+    let by = makeString(["%d", toString(aO)], a)
350+    let bz = makeString(["%d", toString(aP)], a)
351+    let bA = makeString(["%d", toString(bc)], a)
352+    let bB = makeString(["%d", toString(bd)], a)
353+    let bC = makeString(["%b", be], a)
354+    let bD = makeString(["%d", toString(bf)], a)
355+    let bE = makeString(["%d", toString(bg)], a)
356+    let bF = makeString(["%d", toString(ba)], a)
357+    let bG = makeString(["%d", toString(0)], a)
358+    let bH = makeString(["%s", bh], a)
359+[al(bi, bv), al(bk, bx), ac(br, bE), ac(bq, bD), al(bj, bw), al(bs, bF), al(bl, by), al(bm, bz), ac(bn, bA), ac(bt, bG), al(bo, bB), al(bp, bC), ac(bu, bH)]
360+    }
361+
362+
363+func bI (h,bJ) = {
364+    let bK = av()
365+    (fraction(c, (f * bK), g(h)) * bJ)
366+    }
367+
368+
369+func bL (h,bM) = {
370+    let bN = fraction(h, 15, 10)
371+    ((bM / ((h * bN) - h)) * f)
372+    }
373+
374+
375+func bO (bP) = {
376+    let bQ = Y(L(J), "could not get the running StawLP")
377+[aa(J, (bQ + bP))]
378+    }
379+
380+
381+func bR (bP) = {
382+    let bQ = Y(L(J), "could not get the running StawLP")
383+[aa(J, (bQ - bP))]
384+    }
385+
386+
387+func bS (bP) = {
388+    let bT = Y(L(I), "could not get total locked waves")
389+[aa(I, (bT + bP))]
390+    }
391+
392+
393+func bU (bP) = {
394+    let bT = Y(L(I), "could not get total locked waves")
395+[aa(I, (bT - bP))]
396+    }
397+
398+
399+func bV (bW) = {
400+    let bX = {
401+        let U = blockInfoByHeight(bW)
402+        if ($isInstanceOf(U, "BlockInfo"))
403+            then {
404+                let bY = U
405+                bY.timestamp
406+                }
407+            else throw("counld get timestamp")
408+        }
409+    bX
410+    }
411+
412+
413+@Callable(ao)
414+func getEmission (h,bM) = {
415+    let bZ = an(ao)
416+    if ((bZ == bZ))
417+        then $Tuple2(nil, bL(h, bM))
418+        else throw("Strict value is not equal to itself.")
419+    }
420+
421+
422+
423+@Callable(ao)
424+func init (ap,ca,cb,cc) = {
425+    let cd = if (isDefined(N(n)))
426+        then an(ao)
427+        else true
428+    if ((cd == cd))
429+        then {
430+            let bZ = ar(ap)
431+            if ((bZ == bZ))
432+                then {
433+                    let ce = ar(ca)
434+                    if ((ce == ce))
435+                        then {
436+                            let cf = ar(cc)
437+                            if ((cf == cf))
438+                                then {
439+                                    let cg = S(p, 0)
440+                                    let ch = S(k, 0)
441+                                    let ci = S(l, c)
442+                                    let cj = S(H, 0)
443+                                    let ck = S(J, 0)
444+                                    let cl = S(K, 0)
445+                                    let cm = S(I, 0)
446+[af(n, ap), af(o, ca), af(m, cb), af(q, cc), af(p, cg), af(l, ci), af(k, ch), af(I, cm), af(J, ck), af(H, cj)]
447+                                    }
448+                                else throw("Strict value is not equal to itself.")
449+                            }
450+                        else throw("Strict value is not equal to itself.")
451+                    }
452+                else throw("Strict value is not equal to itself.")
453+            }
454+        else throw("Strict value is not equal to itself.")
455+    }
456+
457+
458+
459+@Callable(ao)
460+func modifyGlobalParams (W) = {
461+    let bZ = an(ao)
462+    if ((bZ == bZ))
463+        then {
464+            let ce = ad((size(W) == 2), "[global_key, value] pairs expected")
465+            if ((ce == ce))
466+                then {
467+                    let M = W[0]
468+                    let cn = parseInt(W[1])
469+                    let U = cn
470+                    if ($isInstanceOf(U, "Int"))
471+                        then {
472+                            let aK = U
473+                            let co = ad((N(M) == unit), (("key " + M) + " not recognized"))
474+                            if ((co == co))
475+                                then [af(M, aK)]
476+                                else throw("Strict value is not equal to itself.")
477+                            }
478+                        else if ($isInstanceOf(U, "Unit"))
479+                            then {
480+                                let aK = U
481+                                let co = ad((N(M) == unit), (("key " + M) + " not recognized"))
482+                                if ((co == co))
483+                                    then {
484+                                        let cp = ar(W[1])
485+                                        if ((cp == cp))
486+                                            then [af(M, W[1])]
487+                                            else throw("Strict value is not equal to itself.")
488+                                        }
489+                                    else throw("Strict value is not equal to itself.")
490+                                }
491+                            else $Tuple2(nil, true)
492+                    }
493+                else throw("Strict value is not equal to itself.")
494+            }
495+        else throw("Strict value is not equal to itself.")
496+    }
497+
498+
499+
500+@Callable(ao)
501+func revokeLock () = {
502+    let bZ = an(ao)
503+    if ((bZ == bZ))
504+        then nil
505+        else throw("Strict value is not equal to itself.")
506+    }
507+
508+
509+
510+@Callable(ao)
511+func claim (aX) = {
512+    let cq = toBase58String(ao.caller.bytes)
513+    let cr = makeString([cq, aX, z], a)
514+    let cs = makeString([cq, aX, w], a)
515+    let ct = makeString([cq, aX, y], a)
516+    let cu = makeString([cq, aX, E], a)
517+    let cv = makeString([cq, aX, F], a)
518+    let cw = makeString([cq, aX, B], a)
519+    let cx = makeString([cq, aX, z], a)
520+    let cy = makeString([cq, v], a)
521+    let cz = makeString([cq, aX, G], a)
522+    let cA = makeString([cq, aX, G], a)
523+    let cB = Q(I)
524+    if ((cB == cB))
525+        then {
526+            let cC = Q(J)
527+            if ((cC == cC))
528+                then {
529+                    let be = {
530+                        let U = aI(ct)
531+                        if ($isInstanceOf(U, "ByteVector"))
532+                            then {
533+                                let cD = U
534+                                cD
535+                                }
536+                            else throw("failed to get lease id")
537+                        }
538+                    if ((be == be))
539+                        then {
540+                            let cE = {
541+                                let U = aI(cy)
542+                                if ($isInstanceOf(U, "Int"))
543+                                    then {
544+                                        let cD = U
545+                                        cD
546+                                        }
547+                                    else throw("failed to get total waves locked by this address")
548+                                }
549+                            if ((cE == cE))
550+                                then {
551+                                    let aO = {
552+                                        let U = aI(cx)
553+                                        if ($isInstanceOf(U, "Int"))
554+                                            then {
555+                                                let cD = U
556+                                                cD
557+                                                }
558+                                            else throw("failed to get total waves locked")
559+                                        }
560+                                    if ((aO == aO))
561+                                        then {
562+                                            let cF = {
563+                                                let U = aI(cv)
564+                                                if ($isInstanceOf(U, "Int"))
565+                                                    then {
566+                                                        let cD = U
567+                                                        cD
568+                                                        }
569+                                                    else throw("failed to get total waves claimed")
570+                                                }
571+                                            if ((cF == cF))
572+                                                then {
573+                                                    let bc = {
574+                                                        let U = aI(cw)
575+                                                        if ($isInstanceOf(U, "Int"))
576+                                                            then {
577+                                                                let cD = U
578+                                                                cD
579+                                                                }
580+                                                            else throw("failed to get stawPL")
581+                                                        }
582+                                                    if ((bc == bc))
583+                                                        then {
584+                                                            let cG = {
585+                                                                let U = aI(cu)
586+                                                                if ($isInstanceOf(U, "Int"))
587+                                                                    then {
588+                                                                        let cD = U
589+                                                                        cD
590+                                                                        }
591+                                                                    else throw("failed to get lock period timespam")
592+                                                                }
593+                                                            if ((cG == cG))
594+                                                                then {
595+                                                                    let cH = {
596+                                                                        let U = bV(height)
597+                                                                        if ($isInstanceOf(U, "Int"))
598+                                                                            then {
599+                                                                                let cD = U
600+                                                                                cD
601+                                                                                }
602+                                                                            else throw("failed to get current timestamp")
603+                                                                        }
604+                                                                    if ((cH == cH))
605+                                                                        then {
606+                                                                            let bM = {
607+                                                                                let U = aI(cr)
608+                                                                                if ($isInstanceOf(U, "Int"))
609+                                                                                    then {
610+                                                                                        let cD = U
611+                                                                                        cD
612+                                                                                        }
613+                                                                                    else throw("failed to get collateral")
614+                                                                                }
615+                                                                            if ((bM == bM))
616+                                                                                then {
617+                                                                                    let h = {
618+                                                                                        let U = aI(cs)
619+                                                                                        if ($isInstanceOf(U, "Int"))
620+                                                                                            then {
621+                                                                                                let cD = U
622+                                                                                                cD
623+                                                                                                }
624+                                                                                            else throw("failed to get lockPeriod")
625+                                                                                        }
626+                                                                                    if ((h == h))
627+                                                                                        then {
628+                                                                                            let cI = {
629+                                                                                                let U = aI(cz)
630+                                                                                                if ($isInstanceOf(U, "String"))
631+                                                                                                    then {
632+                                                                                                        let cD = U
633+                                                                                                        cD
634+                                                                                                        }
635+                                                                                                    else throw("failed to get lease state")
636+                                                                                                }
637+                                                                                            if ((cI == cI))
638+                                                                                                then {
639+                                                                                                    let bh = {
640+                                                                                                        let U = aI(cA)
641+                                                                                                        if ($isInstanceOf(U, "String"))
642+                                                                                                            then {
643+                                                                                                                let cD = U
644+                                                                                                                cD
645+                                                                                                                }
646+                                                                                                            else throw("failed to get lease state for user")
647+                                                                                                        }
648+                                                                                                    if ((bh == bh))
649+                                                                                                        then {
650+                                                                                                            let bZ = ad((cG > cH), "lock period for this entry has not elapsed")
651+                                                                                                            if ((bZ == bZ))
652+                                                                                                                then {
653+                                                                                                                    let cJ = if ((cI == "leased"))
654+                                                                                                                        then $Tuple2(LeaseCancel(be), ac(cz, "cancelled"))
655+                                                                                                                        else $Tuple2(ac(cz, "cancelled"), ac(cz, "cancelled"))
656+                                                                                                                    if ((cJ == cJ))
657+                                                                                                                        then {
658+                                                                                                                            let ce = ad(if ((0 == aO))
659+                                                                                                                                then true
660+                                                                                                                                else (0 == bc), "all claims exhausted for this trx")
661+                                                                                                                            if ((ce == ce))
662+                                                                                                                                then {
663+                                                                                                                                    let cK = (bL(h, bM) * f)
664+                                                                                                                                    let cL = {
665+                                                                                                                                        let cM = (cH - cG)
666+                                                                                                                                        let cN = (cM / f)
667+                                                                                                                                        if ((cN == 0))
668+                                                                                                                                            then throw("less than 24hrs before first claim")
669+                                                                                                                                            else if (((cM % f) != 0))
670+                                                                                                                                                then throw("already claimed or less than 24hrs before next claim")
671+                                                                                                                                                else if ((cN > h))
672+                                                                                                                                                    then throw("all claims exhausted")
673+                                                                                                                                                    else {
674+                                                                                                                                                        let cO = (cN * cK)
675+                                                                                                                                                        let cP = ad((cO == cF), "can only claim once in 24hrs")
676+                                                                                                                                                        if ((cP == cP))
677+                                                                                                                                                            then {
678+                                                                                                                                                                let cQ = ad(((cO + cF) > aO), "all claims exhausted")
679+                                                                                                                                                                if ((cQ == cQ))
680+                                                                                                                                                                    then {
681+                                                                                                                                                                        let cR = if ((cN == 1))
682+                                                                                                                                                                            then cO
683+                                                                                                                                                                            else (cO - cF)
684+                                                                                                                                                                        let cS = cO
685+                                                                                                                                                                        let cT = if ((cN == 1))
686+                                                                                                                                                                            then (aO - cO)
687+                                                                                                                                                                            else (aO - (cO - cF))
688+                                                                                                                                                                        let cU = if ((cN == 1))
689+                                                                                                                                                                            then (bc - cO)
690+                                                                                                                                                                            else (bc - (cO - cF))
691+                                                                                                                                                                        let cV = (cB - cT)
692+                                                                                                                                                                        let cW = (cC - cU)
693+                                                                                                                                                                        let cX = (cE - cR)
694+                                                                                                                                                                        let by = makeString(["%d", toString(cT)], a)
695+                                                                                                                                                                        let bA = makeString(["%d", toString(cU)], a)
696+                                                                                                                                                                        let bG = makeString(["%d", toString(cS)], a)
697+                                                                                                                                                                        let cY = makeString(["%d", toString(cX)], a)
698+[cJ._1, cJ._2, ac(cx, by), ac(cw, bA), ac(cv, bG), ac(cy, cY), aa(I, cV), aa(J, cW), ScriptTransfer(Address(ao.caller.bytes), cR, unit)]
699+                                                                                                                                                                        }
700+                                                                                                                                                                    else throw("Strict value is not equal to itself.")
701+                                                                                                                                                                }
702+                                                                                                                                                            else throw("Strict value is not equal to itself.")
703+                                                                                                                                                        }
704+                                                                                                                                        }
705+                                                                                                                                    if ((cL == cL))
706+                                                                                                                                        then cL
707+                                                                                                                                        else throw("Strict value is not equal to itself.")
708+                                                                                                                                    }
709+                                                                                                                                else throw("Strict value is not equal to itself.")
710+                                                                                                                            }
711+                                                                                                                        else throw("Strict value is not equal to itself.")
712+                                                                                                                    }
713+                                                                                                                else throw("Strict value is not equal to itself.")
714+                                                                                                            }
715+                                                                                                        else throw("Strict value is not equal to itself.")
716+                                                                                                    }
717+                                                                                                else throw("Strict value is not equal to itself.")
718+                                                                                            }
719+                                                                                        else throw("Strict value is not equal to itself.")
720+                                                                                    }
721+                                                                                else throw("Strict value is not equal to itself.")
722+                                                                            }
723+                                                                        else throw("Strict value is not equal to itself.")
724+                                                                    }
725+                                                                else throw("Strict value is not equal to itself.")
726+                                                            }
727+                                                        else throw("Strict value is not equal to itself.")
728+                                                    }
729+                                                else throw("Strict value is not equal to itself.")
730+                                            }
731+                                        else throw("Strict value is not equal to itself.")
732+                                    }
733+                                else throw("Strict value is not equal to itself.")
734+                            }
735+                        else throw("Strict value is not equal to itself.")
736+                    }
737+                else throw("Strict value is not equal to itself.")
738+            }
739+        else throw("Strict value is not equal to itself.")
740+    }
741+
742+
743+
744+@Callable(ao)
745+func mintStaw (h) = {
746+    let cq = toBase58String(ao.caller.bytes)
747+    let cZ = toBase58String(ao.transactionId)
748+    let bZ = ad((1 != size(ao.payments)), "no payments attached")
749+    if ((bZ == bZ))
750+        then {
751+            let ce = if (isDefined(ao.payments[0].assetId))
752+                then throw("only waves supported")
753+                else true
754+            if ((ce == ce))
755+                then {
756+                    let da = ao.payments[0].amount
757+                    let cf = if (if ((d > da))
758+                        then true
759+                        else (da > e))
760+                        then throw("amount to lock is out of range")
761+                        else true
762+                    if ((cf == cf))
763+                        then {
764+                            let db = if ((b > h))
765+                                then throw("minimum of 14 days lock period")
766+                                else true
767+                            if ((db == db))
768+                                then {
769+                                    let dc = bI(h, da)
770+                                    let aQ = da
771+                                    let dd = fraction(dc, 10, 100)
772+                                    let de = (dc - dd)
773+                                    let df = (bV(height) + ai(h))
774+                                    if ((df == df))
775+                                        then {
776+                                            let dg = (Y(L(K), "global index not previously defined") + 1)
777+                                            if ((dg == dg))
778+                                                then {
779+                                                    let dh = Address(fromBase58String(V(N(o), "dfx not previously defined")))
780+                                                    if ((dh == dh))
781+                                                        then {
782+                                                            let ax = fromBase58String(V(N(m), "asset id not previously defined"))
783+                                                            if ((ax == ax))
784+                                                                then {
785+                                                                    let di = Address(fromBase58String(V(N(q), "lease node not previously defined")))
786+                                                                    if ((di == di))
787+                                                                        then {
788+                                                                            let dj = makeString([cq, u], a)
789+                                                                            let dk = makeString([cq, v], a)
790+                                                                            let dl = {
791+                                                                                let U = aI(dj)
792+                                                                                if ($isInstanceOf(U, "Int"))
793+                                                                                    then {
794+                                                                                        let aK = U
795+                                                                                        (aK + 1)
796+                                                                                        }
797+                                                                                    else 0
798+                                                                                }
799+                                                                            if ((dl == dl))
800+                                                                                then {
801+                                                                                    let dm = {
802+                                                                                        let U = aI(dk)
803+                                                                                        if ($isInstanceOf(U, "Int"))
804+                                                                                            then {
805+                                                                                                let aK = U
806+                                                                                                (aK + da)
807+                                                                                                }
808+                                                                                            else da
809+                                                                                        }
810+                                                                                    if ((dm == dm))
811+                                                                                        then {
812+                                                                                            let dn = Lease(di, da)
813+                                                                                            if ((dn == dn))
814+                                                                                                then {
815+                                                                                                    let do = toBase58String(calculateLeaseId(dn))
816+                                                                                                    if ((do == do))
817+                                                                                                        then (([dn, ScriptTransfer(dh, dd, ax), ScriptTransfer(Address(ao.caller.bytes), de, ax)] ++ aW(cZ, cq, h, df, dg, da, de, aQ, height, do, dm, dl, "leased")) ++ aN(da, dc, aQ, dg))
818+                                                                                                        else throw("Strict value is not equal to itself.")
819+                                                                                                    }
820+                                                                                                else throw("Strict value is not equal to itself.")
821+                                                                                            }
822+                                                                                        else throw("Strict value is not equal to itself.")
823+                                                                                    }
824+                                                                                else throw("Strict value is not equal to itself.")
825+                                                                            }
826+                                                                        else throw("Strict value is not equal to itself.")
827+                                                                    }
828+                                                                else throw("Strict value is not equal to itself.")
829+                                                            }
830+                                                        else throw("Strict value is not equal to itself.")
831+                                                    }
832+                                                else throw("Strict value is not equal to itself.")
833+                                            }
834+                                        else throw("Strict value is not equal to itself.")
835+                                    }
836+                                else throw("Strict value is not equal to itself.")
837+                            }
838+                        else throw("Strict value is not equal to itself.")
839+                    }
840+                else throw("Strict value is not equal to itself.")
841+            }
842+        else throw("Strict value is not equal to itself.")
843+    }
844+
845+
github/deemru/w8io/169f3d6 
94.27 ms ◑