tx · 7NXR58diaiVszBSE7KAcn8TYT2ai7odPTAt3zd4BFT2m

3MsXpzisJAwnzUr7XrEoW1BZo4U6rw4tsYK:  -0.10000000 Waves

2022.10.11 11:56 [2267471] smart account 3MsXpzisJAwnzUr7XrEoW1BZo4U6rw4tsYK > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7NXR58diaiVszBSE7KAcn8TYT2ai7odPTAt3zd4BFT2m",
    "fee": 10000000,
    "feeAssetId": null,
    "timestamp": 1665478613752,
    "version": 2,
    "chainId": 84,
    "sender": "3MsXpzisJAwnzUr7XrEoW1BZo4U6rw4tsYK",
    "senderPublicKey": "FFdBua5rzzMkZebvsvmN7sAdU7XhFK8QNJ3hiwwxAYRA",
    "proofs": [
        "32bmQ6SvCLv9qUWcmPomVBxZugkKgZugiwQDU9RsuyEGNTwRSpzcSWVQVxoaxHDTnYbMNKzcUpBxVcErUqixt8is"
    ],
    "script": "base64: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",
    "height": 2267471,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 4G6GZo7sucHyRPB4SLjmriLKDCARZMbA3eZLdqa1QdyS

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "_total_share_tokens_locked"
5+
6+let b = "share_limit_on_first_harvest"
7+
8+let c = "active"
9+
10+let d = "shutdown_cause"
11+
12+let e = "_current_pool_fraction_reward"
13+
14+let f = "_previous_pool_fraction_reward"
15+
16+let g = "_pool_reward_update_height"
17+
18+let h = "total_reward_per_block_current"
19+
20+let i = "total_reward_per_block_previous"
21+
22+let j = "reward_update_height"
23+
24+let k = "_last_interest"
25+
26+let l = "_last_interest_height"
27+
28+let m = "_share_tokens_locked"
29+
30+let n = "_last_interest"
31+
32+let o = "SWOP_id"
33+
34+let p = "_SWOP_claimed_amount"
35+
36+let q = "_SWOP_last_claimed_amount"
37+
38+let r = "_available_SWOP"
39+
40+let s = "farming_start_height"
41+
42+let t = "apy"
43+
44+let u = "previous_total_vote_SWOP"
45+
46+let v = "swop_year_emission"
47+
48+let w = "A_asset_balance"
49+
50+let x = "B_asset_balance"
51+
52+let y = "_harvest_pool_activeVote_struc"
53+
54+let z = "_harvest_user_pool_activeVote_struc"
55+
56+let A = "share_limit_on_first_harvest"
57+
58+let B = "A_asset_id"
59+
60+let C = "B_asset_id"
61+
62+let D = "first_harvest_height"
63+
64+let E = "first_harvest"
65+
66+let F = "sum_reward_previous"
67+
68+let G = "sum_reward_current"
69+
70+let H = 10106
71+
72+let I = 10000000000
73+
74+let J = 10
75+
76+let K = 1000
77+
78+let L = 100000
79+
80+let M = 1000000
81+
82+let N = 100000000
83+
84+let O = 100000000000
85+
86+let P = "admin_pub_1"
87+
88+let Q = "admin_pub_2"
89+
90+let R = "admin_pub_3"
91+
92+let S = "admin_invoke_pub"
93+
94+let T = "money_box_address"
95+
96+let U = "voting_address"
97+
98+let V = "governance_address"
99+
100+let W = "lp_farming"
101+
102+let X = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
103+
104+func Y (Z) = {
105+    let aa = getString(X, Z)
106+    if ($isInstanceOf(aa, "String"))
107+        then {
108+            let ab = aa
109+            fromBase58String(ab)
110+            }
111+        else {
112+            let ac = aa
113+            throw((Z + "is empty"))
114+            }
115+    }
116+
117+
118+let ad = Y(P)
119+
120+let ae = Y(Q)
121+
122+let af = Y(R)
123+
124+let ag = Address(Y(T))
125+
126+let ah = Address(Y(U))
127+
128+let ai = Address(Y(V))
129+
130+let aj = Y(S)
131+
132+let ak = Address(Y(W))
133+
134+func al (am) = getStringValue(am, B)
135+
136+
137+func an (am) = getStringValue(am, C)
138+
139+
140+func ao (am) = if ((al(am) == "WAVES"))
141+    then unit
142+    else fromBase58String(al(am))
143+
144+
145+func ap (am) = if ((an(am) == "WAVES"))
146+    then unit
147+    else fromBase58String(an(am))
148+
149+
150+let aq = "base_period"
151+
152+let ar = "period_length"
153+
154+let as = "start_height"
155+
156+let at = "first_harvest_height"
157+
158+let au = "duration_full_vote_power"
159+
160+let av = "min_vote_power"
161+
162+let aw = valueOrErrorMessage(getInteger(ah, aq), "Empty kBasePeriod")
163+
164+let ax = valueOrErrorMessage(getInteger(ah, as), "Empty kStartHeight")
165+
166+let ay = valueOrErrorMessage(getInteger(ah, ar), "Empty kPeriodLength")
167+
168+let az = valueOrErrorMessage(getInteger(ah, au), "Empty kDurationFullVotePower")
169+
170+let aA = valueOrErrorMessage(getInteger(ah, av), "Empty kMinVotePower")
171+
172+let aB = getBooleanValue(this, c)
173+
174+let aC = (aw + ((height - ax) / ay))
175+
176+func aD (am) = valueOrElse(getIntegerValue(am, A), 0)
177+
178+
179+let aE = getIntegerValue(this, t)
180+
181+let aF = getIntegerValue(this, v)
182+
183+func aG (am) = {
184+    let aa = ao(am)
185+    if ($isInstanceOf(aa, "ByteVector"))
186+        then {
187+            let aH = aa
188+            value(assetInfo(aH)).name
189+            }
190+        else if ($isInstanceOf(aa, "Unit"))
191+            then {
192+                let aI = aa
193+                "WAVES"
194+                }
195+            else throw("Match error")
196+    }
197+
198+
199+func aJ (am) = {
200+    let aa = ap(am)
201+    if ($isInstanceOf(aa, "ByteVector"))
202+        then {
203+            let aH = aa
204+            value(assetInfo(aH)).name
205+            }
206+        else if ($isInstanceOf(aa, "Unit"))
207+            then {
208+                let aI = aa
209+                "WAVES"
210+                }
211+            else throw("Match error")
212+    }
213+
214+
215+let aK = fromBase58String(getStringValue(this, o))
216+
217+func aL (am) = valueOrElse(getBoolean(am, E), false)
218+
219+
220+func aM (am) = valueOrElse(getInteger(am, D), 0)
221+
222+
223+func aN (am) = valueOrErrorMessage(getInteger(am, w), ("No data on the key: " + w))
224+
225+
226+func aO (am) = valueOrErrorMessage(getInteger(am, x), ("No data on the key: " + x))
227+
228+
229+func aP (am) = valueOrErrorMessage(getInteger(am, b), ("No data on the key: " + b))
230+
231+
232+func aQ (am) = valueOrErrorMessage(getInteger(this, (am + a)), (("No data on the key: " + am) + a))
233+
234+
235+func aR (am) = fromBase58String(getStringValue(value(addressFromString(am)), "share_asset_id"))
236+
237+
238+func aS (aT) = {
239+    let aa = aT
240+    if ($isInstanceOf(aa, "ByteVector"))
241+        then {
242+            let aH = aa
243+            assetBalance(this, aH)
244+            }
245+        else if ($isInstanceOf(aa, "Unit"))
246+            then {
247+                let aI = aa
248+                wavesBalance(this).available
249+                }
250+            else throw("Match error")
251+    }
252+
253+
254+func aU (aT) = {
255+    let aa = aT
256+    if ($isInstanceOf(aa, "ByteVector"))
257+        then {
258+            let aH = aa
259+            let aV = toBase58String(aH)
260+            let aW = valueOrErrorMessage(assetInfo(aH), (("Asset " + aV) + " doesn't exist"))
261+            $Tuple3(aV, aW.name, aW.decimals)
262+            }
263+        else if ($isInstanceOf(aa, "Unit"))
264+            then {
265+                let aI = aa
266+                $Tuple3("WAVES", "WAVES", 8)
267+                }
268+            else throw("Match error")
269+    }
270+
271+
272+func aX (aY,aZ) = {
273+    let ba = value(assetInfo(aY)).decimals
274+    let bb = value(assetInfo(aZ)).decimals
275+    let bc = ((bb - ba) + 8)
276+    pow(10, 0, bc, 0, 0, DOWN)
277+    }
278+
279+
280+func bd (am,be) = valueOrElse(getInteger(this, (((am + "_") + toString(be)) + r)), 0)
281+
282+
283+func bf (am) = {
284+    let bg = valueOrErrorMessage(getInteger(ai, h), ((("No data on the key: " + h) + " at address ") + toString(ai)))
285+    let bh = valueOrErrorMessage(getInteger(ai, i), ((("No data on the key: " + i) + " at address ") + toString(ai)))
286+    let bi = valueOrErrorMessage(getInteger(ai, (am + e)), (((("No data on the key: " + am) + e) + " at address ") + toString(ai)))
287+    let bj = valueOrErrorMessage(getInteger(ai, j), ((("No data on the key: " + j) + " at address ") + toString(ai)))
288+    let bk = valueOrElse(getInteger(ai, (am + g)), 0)
289+    let bl = valueOrErrorMessage(getInteger(ai, (am + f)), (((("No data on the key: " + am) + f) + " at address ") + toString(ai)))
290+    let bm = fraction(bg, bi, I)
291+    let bn = fraction(bh, bl, I)
292+    if (if ((bm > bg))
293+        then true
294+        else (bn > bh))
295+        then throw("rewardPoolCurrent > totalRewardPerBlockCurrent or rewardPoolPrevious > totalRewardPerBlockPrevious")
296+        else $Tuple4(bm, bj, bn, bk)
297+    }
298+
299+
300+func bo (am) = {
301+    let bp = valueOrErrorMessage(getInteger(this, (am + k)), (("No data on the key: " + am) + k))
302+    let bq = valueOrElse(getInteger(this, (am + l)), height)
303+    $Tuple2(bq, bp)
304+    }
305+
306+
307+func br (am,bs) = {
308+    let bt = getInteger(this, (((am + "_") + toString(bs)) + n))
309+    let bu = getInteger(this, (((am + "_") + toString(bs)) + m))
310+    let bp = valueOrErrorMessage(getInteger(this, (am + k)), (("No data on the key: " + am) + k))
311+    let bv = {
312+        let aa = bt
313+        if ($isInstanceOf(aa, "Int"))
314+            then {
315+                let bt = aa
316+                bt
317+                }
318+            else bp
319+        }
320+    let bw = {
321+        let aa = bu
322+        if ($isInstanceOf(aa, "Int"))
323+            then {
324+                let bu = aa
325+                bu
326+                }
327+            else 0
328+        }
329+    $Tuple2(bv, bw)
330+    }
331+
332+
333+func bx (bq,bj,bk,bp,by,bz,bA,bB,bC,bD) = if ((bz == 0))
334+    then 0
335+    else if ((bk != 0))
336+        then if (if ((bj > height))
337+            then (bj == bk)
338+            else false)
339+            then {
340+                let bE = (bA * (height - bq))
341+                (bp + fraction(bE, bC, bz))
342+                }
343+            else if (if ((height > bj))
344+                then (bj != bk)
345+                else false)
346+                then {
347+                    let bE = (bA * (height - bq))
348+                    (bp + fraction(bE, bC, bz))
349+                    }
350+                else if (if (if ((height > bj))
351+                    then (bj == bk)
352+                    else false)
353+                    then (bq > bj)
354+                    else false)
355+                    then {
356+                        let bE = (by * (height - bq))
357+                        (bp + fraction(bE, bC, bz))
358+                        }
359+                    else {
360+                        let bF = (bA * (bj - bq))
361+                        let bG = (bp + fraction(bF, bC, bz))
362+                        let bE = (by * (height - bj))
363+                        (bG + fraction(bE, bC, bz))
364+                        }
365+        else if ((bj > height))
366+            then {
367+                let bE = (bA * (height - bq))
368+                (bp + fraction(bE, bC, bz))
369+                }
370+            else if ((bq > bj))
371+                then {
372+                    let bE = (by * (height - bq))
373+                    (bp + fraction(bE, bC, bz))
374+                    }
375+                else {
376+                    let bF = (bA * (bj - bq))
377+                    let bG = (bp + fraction(bF, bC, bz))
378+                    let bE = (by * (height - bj))
379+                    (bG + fraction(bE, bC, bz))
380+                    }
381+
382+
383+func bH (am,bI,bD) = {
384+    let bB = aR(am)
385+    let bC = aX(aK, bB)
386+    let bz = aQ(am)
387+    let bJ = bo(am)
388+    let bq = bJ._1
389+    let bp = bJ._2
390+    let bK = bf(am)
391+    let by = bK._1
392+    let bj = bK._2
393+    let bA = bK._3
394+    let bk = bK._4
395+    let bL = br(am, bI)
396+    let bt = bL._1
397+    let bw = bL._2
398+    let bM = bx(bq, bj, bk, bp, by, bz, bA, bB, bC, bD)
399+    let bN = fraction(bw, (bM - bt), bC)
400+    let bO = bM
401+    $Tuple4(bO, bM, bN, bw)
402+    }
403+
404+
405+func bP (am) = {
406+    let bQ = bo(am)
407+    let bq = bQ._1
408+    let bp = bQ._2
409+    let bR = bf(am)
410+    let by = bR._1
411+    let bj = bR._2
412+    let bA = bR._3
413+    let bk = bR._4
414+    let bz = aQ(am)
415+    if (if ((bz == 0))
416+        then (bk == 0)
417+        else false)
418+        then if ((bj > height))
419+            then {
420+                let bE = (bA * (height - bq))
421+                bE
422+                }
423+            else if ((bq > bj))
424+                then {
425+                    let bE = (by * (height - bq))
426+                    bE
427+                    }
428+                else {
429+                    let bF = (bA * (bj - bq))
430+                    let bE = (by * (height - bj))
431+                    (bE + bF)
432+                    }
433+        else if (if ((bz == 0))
434+            then (bk != 0)
435+            else false)
436+            then if (if ((bj > height))
437+                then (bj == bk)
438+                else false)
439+                then {
440+                    let bE = (bA * (height - bq))
441+                    bE
442+                    }
443+                else if (if ((height > bj))
444+                    then (bj != bk)
445+                    else false)
446+                    then {
447+                        let bE = (bA * (height - bq))
448+                        bE
449+                        }
450+                    else if (if (if ((height > bj))
451+                        then (bj == bk)
452+                        else false)
453+                        then (bq > bj)
454+                        else false)
455+                        then {
456+                            let bE = (by * (height - bq))
457+                            bE
458+                            }
459+                        else {
460+                            let bF = (bA * (bj - bq))
461+                            let bE = (by * (height - bj))
462+                            (bE + bF)
463+                            }
464+            else 0
465+    }
466+
467+
468+func bS (am,bT) = {
469+    let bU = fromBase58String(getStringValue(value(addressFromString(am)), "share_asset_id"))
470+    if ((bT == bU))
471+        then true
472+        else false
473+    }
474+
475+
476+func bV (am,be) = valueOrElse(getInteger(this, (((am + "_") + toString(be)) + p)), 0)
477+
478+
479+func bW (bX) = [BooleanEntry(c, false), StringEntry(d, bX)]
480+
481+
482+@Callable(bY)
483+func init (bZ) = if (isDefined(getString(this, o)))
484+    then throw("SWOP already initialized")
485+    else {
486+        let ca = 100000000000000
487+        let cb = Issue("SWOP", "SWOP protocol token", ca, 8, true)
488+        let cc = calculateAssetId(cb)
489+[BooleanEntry(c, true), Issue("SWOP", "SWOP protocol token", ca, 8, true), StringEntry(o, toBase58String(cc))]
490+        }
491+
492+
493+
494+@Callable(bY)
495+func initPoolShareFarming (am) = if ((bY.caller != this))
496+    then throw("Only the DApp itself can call this function")
497+    else {
498+        let cd = bf(am)
499+        let ce = cd._1
500+        let bj = cd._2
501+        let bA = cd._3
502+        let bk = cd._4
503+[IntegerEntry((am + a), 0), IntegerEntry((am + k), 0), IntegerEntry((am + l), height)]
504+        }
505+
506+
507+
508+@Callable(bY)
509+func updatePoolInterest (am) = if ((bY.caller != ag))
510+    then throw("Only the Admin itself can call this function")
511+    else if (!(aB))
512+        then throw("DApp is inactive at this moment")
513+        else {
514+            let cf = bH(am, addressFromPublicKey(aj), 0)
515+            let bO = cf._1
516+            let bM = cf._2
517+            let bN = cf._3
518+            let bw = cf._4
519+            let cg = bf(am)
520+            let ce = cg._1
521+            let bj = cg._2
522+            let bA = cg._3
523+            let bk = cg._4
524+[IntegerEntry((am + k), bO), IntegerEntry((am + l), height)]
525+            }
526+
527+
528+
529+@Callable(bY)
530+func lockShareTokens (am) = {
531+    let ch = $Tuple2(bY.payments[0].amount, bY.payments[0].assetId)
532+    let bD = ch._1
533+    let bT = ch._2
534+    let ci = aU(bT)
535+    let cj = ci._1
536+    let ck = ci._2
537+    let cl = ci._3
538+    let cm = bH(am, bY.originCaller, bD)
539+    let bO = cm._1
540+    let bM = cm._2
541+    let bN = cm._3
542+    let bw = cm._4
543+    let cn = (bw + bD)
544+    let co = (bd(am, bY.originCaller) + bN)
545+    let cp = aQ(am)
546+    let cq = (cp + bD)
547+    let cr = bV(am, bY.originCaller)
548+    let cs = (cr + bN)
549+    let ct = [IntegerEntry((((am + "_") + toString(bY.originCaller)) + n), bO), IntegerEntry((((am + "_") + toString(bY.originCaller)) + m), cn), IntegerEntry((am + a), cq), IntegerEntry((am + k), bM), IntegerEntry((am + l), height), IntegerEntry((((am + "_") + toString(bY.originCaller)) + p), cs), IntegerEntry((((am + "_") + toString(bY.originCaller)) + q), bN), IntegerEntry((((am + "_") + toString(bY.originCaller)) + r), co)]
550+    let cu = if ((getString(Address(fromBase58String(am)), "version") == "3.0.0"))
551+        then invoke(ak, "updateUserInterest", [am, cn], nil)
552+        else 0
553+    if ((cu == cu))
554+        then if ((0 >= bD))
555+            then throw("You can't lock token")
556+            else if (!(aB))
557+                then throw("DApp is inactive at this moment")
558+                else if (!(bS(am, bT)))
559+                    then throw("Incorrect pmtAssetId")
560+                    else if (if (aL(Address(fromBase58String(am))))
561+                        then (aM(Address(fromBase58String(am))) > height)
562+                        else false)
563+                        then {
564+                            let cv = ((((aM(Address(fromBase58String(am))) - ax) + 1) / ay) - 1)
565+                            let cw = split(getStringValue(ah, (((toString(bY.originCaller) + "_") + am) + "_user_pool_struc")), "_")
566+                            let cx = split(getStringValue(ah, (am + "_pool_struc")), "_")
567+                            let cy = split(valueOrElse(getString(ah, (((toString(bY.originCaller) + "_") + am) + z)), ""), "_")
568+                            let cz = split(valueOrElse(getString(ah, (am + y)), ""), "_")
569+                            let cA = bw
570+                            let cB = if ((toString(aC) == cw[2]))
571+                                then valueOrElse(parseInt(cy[0]), 0)
572+                                else valueOrElse(parseInt(cw[1]), 0)
573+                            let cC = if ((toString(aC) == cx[2]))
574+                                then valueOrElse(parseInt(cz[0]), 0)
575+                                else valueOrElse(parseInt(cx[1]), 0)
576+                            let cD = bP(am)
577+                            if ((cB != 0))
578+                                then {
579+                                    let cE = aP(addressFromStringValue(am))
580+                                    let cF = (fraction(cE, cB, cC) - cA)
581+                                    if (if ((size(cy) > 1))
582+                                        then (valueOrElse(parseInt(cy[1]), 0) >= cv)
583+                                        else false)
584+                                        then throw("You can't share token")
585+                                        else if ((bD > cE))
586+                                            then throw(("You can't share token more than " + toString(cE)))
587+                                            else if ((cF > 0))
588+                                                then if ((fraction(99, aS(bT), 100) > cq))
589+                                                    then throw("Balance of share-token is greater than totalAmount")
590+                                                    else if ((cp == 0))
591+                                                        then (ct ++ [Reissue(aK, cD, true), ScriptTransfer(ag, cD, aK)])
592+                                                        else if ((cF >= bD))
593+                                                            then ct
594+                                                            else throw(("Your maximum share token is " + toString(cF)))
595+                                                else throw("You can't share token")
596+                                    }
597+                                else throw("Your amount of token less than 0")
598+                            }
599+                        else ct
600+        else throw("Strict value is not equal to itself.")
601+    }
602+
603+
604+
605+@Callable(bY)
606+func withdrawShareTokens (am,cG) = {
607+    let cH = fromBase58String(getStringValue(value(addressFromString(am)), "share_asset_id"))
608+    let cI = bH(am, bY.originCaller, 1)
609+    let bO = cI._1
610+    let bM = cI._2
611+    let bN = cI._3
612+    let bw = cI._4
613+    let cn = (bw - cG)
614+    let co = (bd(am, bY.originCaller) + bN)
615+    let cp = aQ(am)
616+    let cq = (cp - cG)
617+    let cr = bV(am, bY.originCaller)
618+    let cs = (cr + bN)
619+    if ((cG > bw))
620+        then throw("Withdraw amount more then user locked amount")
621+        else if (!(aB))
622+            then throw("DApp is inactive at this moment")
623+            else if ((cG > bw))
624+                then throw("Withdraw amount more then user locked amount")
625+                else if ((fraction(99, (aS(cH) - cG), 100) > cq))
626+                    then throw("Balance of share-token is greater than totalAmount")
627+                    else {
628+                        let cu = if ((getString(Address(fromBase58String(am)), "version") == "3.0.0"))
629+                            then invoke(ak, "updateUserInterest", [am, cn], nil)
630+                            else 0
631+                        if ((cu == cu))
632+                            then [IntegerEntry((((am + "_") + toString(bY.originCaller)) + n), bO), IntegerEntry((((am + "_") + toString(bY.originCaller)) + m), cn), IntegerEntry((am + k), bM), IntegerEntry((am + l), height), IntegerEntry((am + a), cq), IntegerEntry((((am + "_") + toString(bY.originCaller)) + r), co), IntegerEntry((((am + "_") + toString(bY.originCaller)) + p), cs), IntegerEntry((((am + "_") + toString(bY.originCaller)) + q), bN), ScriptTransfer(bY.caller, cG, cH)]
633+                            else throw("Strict value is not equal to itself.")
634+                        }
635+    }
636+
637+
638+
639+@Callable(bY)
640+func claim (am) = {
641+    let cH = fromBase58String(getStringValue(value(addressFromString(am)), "share_asset_id"))
642+    let bz = aQ(am)
643+    let cJ = bo(am)
644+    let bq = cJ._1
645+    let bp = cJ._2
646+    let cK = bf(am)
647+    let by = cK._1
648+    let bj = cK._2
649+    let bA = cK._3
650+    let bk = cK._4
651+    let cL = bH(am, bY.caller, 1)
652+    let bO = cL._1
653+    let bM = cL._2
654+    let bN = cL._3
655+    let bw = cL._4
656+    let cM = (bd(am, bY.caller) + bN)
657+    let cr = bV(am, bY.caller)
658+    let cs = (cr + bN)
659+    if ((cM == 0))
660+        then throw("You have 0 available SWOP")
661+        else if (!(aB))
662+            then throw("DApp is inactive at this moment")
663+            else if ((cM == 0))
664+                then throw("You have 0 available SWOP")
665+                else if ((fraction(99, aS(cH), 100) > bz))
666+                    then throw("Balance of share-token is greater than totalAmount")
667+                    else [IntegerEntry((((am + "_") + toString(bY.caller)) + n), bO), IntegerEntry((am + k), bM), IntegerEntry((am + l), height), IntegerEntry((((am + "_") + toString(bY.caller)) + r), 0), Reissue(aK, cM, true), IntegerEntry((((am + "_") + toString(bY.caller)) + p), cs), IntegerEntry((((am + "_") + toString(bY.caller)) + q), bN), ScriptTransfer(bY.caller, cM, aK)]
668+    }
669+
670+
671+
672+@Callable(bY)
673+func shutdown () = if (!(aB))
674+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, d), "the cause wasn't specified")))
675+    else if (!(containsElement([ad, ae, af], bY.callerPublicKey)))
676+        then throw("Only admin can call this function")
677+        else bW("Paused by admin")
678+
679+
680+
681+@Callable(bY)
682+func activate () = if (aB)
683+    then throw("DApp is already active")
684+    else if (!(containsElement([ad, ae, af], bY.callerPublicKey)))
685+        then throw("Only admin can call this function")
686+        else [BooleanEntry(c, true), DeleteEntry(d)]
687+
688+
689+@Verifier(cN)
690+func cO () = {
691+    let aa = cN
692+    let cP = if (sigVerify(cN.bodyBytes, cN.proofs[0], ad))
693+        then 1
694+        else 0
695+    let cQ = if (sigVerify(cN.bodyBytes, cN.proofs[1], ae))
696+        then 1
697+        else 0
698+    let cR = if (sigVerify(cN.bodyBytes, cN.proofs[2], af))
699+        then 1
700+        else 0
701+    (((cP + cQ) + cR) >= 2)
702+    }
703+
github/deemru/w8io/169f3d6 
36.61 ms ◑