tx · BaXN1ZTRY5MBRaXVTDQBEbpfZWmRTao2USpiSq5AjLd

3N4LqYvK8toVfW83bVrzvm4VoA55PB21Bmy:  -0.14000000 Waves

2021.11.09 10:13 [1783158] smart account 3N4LqYvK8toVfW83bVrzvm4VoA55PB21Bmy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BaXN1ZTRY5MBRaXVTDQBEbpfZWmRTao2USpiSq5AjLd",
    "fee": 14000000,
    "feeAssetId": null,
    "timestamp": 1636442044418,
    "version": 2,
    "chainId": 84,
    "sender": "3N4LqYvK8toVfW83bVrzvm4VoA55PB21Bmy",
    "senderPublicKey": "9NPkhjF6pssidKGhnMzHn9auzo5q5fPBaabRQBx7CaFq",
    "proofs": [
        "62wPJgv4nNGC34zxqaf41WtsoP8mMbeMe1L925EsmD3hXLi5mEXTKQd5s3U1YRNh3NhbPYdAKkU8dvETMsDiaNwf"
    ],
    "script": "base64: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",
    "height": 1783158,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 76yuJkUuBw7RZSq1Jyj8Bw474uU8dZspCBtabHiNmuUj

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = base58'9NPkhjF6pssidKGhnMzHn9auzo5q5fPBaabRQBx7CaFq'
5+
6+let b = base58'9NPkhjF6pssidKGhnMzHn9auzo5q5fPBaabRQBx7CaFq'
7+
8+let c = base58'9NPkhjF6pssidKGhnMzHn9auzo5q5fPBaabRQBx7CaFq'
9+
10+let d = base58'9NPkhjF6pssidKGhnMzHn9auzo5q5fPBaabRQBx7CaFq'
11+
12+let e = "active"
13+
14+let f = "shutdown_cause"
15+
16+let g = "vote_start_height"
17+
18+let h = "vote_end_height"
19+
20+let i = "yes_amount"
21+
22+let j = "no_amount"
23+
24+let k = "_ENNO_vote"
25+
26+let l = "_ENNO_vote_height"
27+
28+let m = "_ENNO_vote_value"
29+
30+let n = "_ENNO_vote_yes_share"
31+
32+let o = "_ENNO_vote_no_share"
33+
34+let p = "total_ENNO_vote_yes"
35+
36+let q = "total_ENNO_vote_no"
37+
38+let r = "_ENNO_amount"
39+
40+let s = "total_ENNO_amount"
41+
42+let t = "total_ENNO_vote"
43+
44+let u = "total_ENNO_vote_share"
45+
46+let v = "_ENNO_claimed_amount"
47+
48+let w = "_ENNO_last_claimed_amount"
49+
50+let x = "share_"
51+
52+let y = valueOrElse(getBoolean(this, e), true)
53+
54+let z = base58'9NPkhjF6pssidKGhnMzHn9auzo5q5fPBaabRQBx7CaFq'
55+
56+let A = base58'6TmLfry3GRQoVSaesGSnp6NtZKveYgEopTLsjaGgXoso'
57+
58+func B (C) = [BooleanEntry(e, false), StringEntry(f, C)]
59+
60+
61+func D (E) = valueOrElse(getInteger(this, (toString(E) + r)), 0)
62+
63+
64+func F () = valueOrElse(getInteger(this, s), 0)
65+
66+
67+func G (E,H) = valueOrElse(getInteger(this, (toString(E) + H)), 0)
68+
69+
70+func I (H) = valueOrElse(getInteger(this, H), 0)
71+
72+
73+func J (K) = {
74+    let L = getInteger(addressFromPublicKey(z), (x + toString(K)))
75+    let M = {
76+        let N = L
77+        if ($isInstanceOf(N, "Int"))
78+            then {
79+                let O = N
80+                O
81+                }
82+            else if ($isInstanceOf(N, "Unit"))
83+                then {
84+                    let O = N
85+                    throw("Only governance qualifiers can call this function.")
86+                    }
87+                else throw("Match error")
88+        }
89+    M
90+    }
91+
92+
93+func P (K) = {
94+    let Q = getInteger(this, (toString(K) + v))
95+    let R = {
96+        let N = Q
97+        if ($isInstanceOf(N, "Int"))
98+            then {
99+                let O = N
100+                O
101+                }
102+            else if ($isInstanceOf(N, "Unit"))
103+                then {
104+                    let O = N
105+                    0
106+                    }
107+                else throw("Match error")
108+        }
109+    R
110+    }
111+
112+
113+func S (T,U) = {
114+    let V = (I(h) - height)
115+    let O = (T * V)
116+    if (U)
117+        then O
118+        else (O * -1)
119+    }
120+
121+
122+@Callable(W)
123+func vote (X,Y,U) = if (!(y))
124+    then throw("DApp is inactive at this moment")
125+    else if ((I(g) > height))
126+        then throw("Voting has not started yet.")
127+        else if ((height > I(h)))
128+            then throw("Voting has already ended.")
129+            else {
130+                let Z = I(p)
131+                let aa = I(q)
132+                let ab = G(W.caller, n)
133+                let ac = G(W.caller, o)
134+                let ad = G(W.caller, k)
135+                let ae = G(W.caller, r)
136+                let af = if (U)
137+                    then (ad + X)
138+                    else (ad - X)
139+                let ag = (ae - ad)
140+                let ah = S(X, U)
141+                if ((X > ag))
142+                    then throw("Vote amount is more than available.")
143+                    else if (Y)
144+                        then {
145+                            let ai = (ab + ah)
146+                            let aj = (Z + ai)
147+                            let ak = I(t)
148+                            let al = (ak + ah)
149+[IntegerEntry((toString(W.caller) + l), height), IntegerEntry((toString(W.caller) + n), ai), IntegerEntry((toString(W.caller) + k), af), IntegerEntry(t, al), IntegerEntry(p, aj)]
150+                            }
151+                        else {
152+                            let ai = (ac + ah)
153+                            let am = (aa + ai)
154+                            let ak = I(t)
155+                            let al = (ak + ah)
156+[IntegerEntry((toString(W.caller) + l), height), IntegerEntry((toString(W.caller) + o), ai), IntegerEntry((toString(W.caller) + k), af), IntegerEntry(t, al), IntegerEntry(q, am)]
157+                            }
158+                }
159+
160+
161+
162+@Callable(W)
163+func lockENNO () = if (!(y))
164+    then throw("DApp is inactive at this moment")
165+    else {
166+        let an = $Tuple2(W.payments[0].amount, W.payments[0].assetId)
167+        let ao = an._1
168+        let ap = an._2
169+        if ((ap != A))
170+            then throw("Incorrect payment assetId only Enno Cash is allowed.")
171+            else {
172+                let ae = D(W.caller)
173+                let aq = (ae + ao)
174+                let ar = F()
175+                let as = (ar + ao)
176+[IntegerEntry((toString(W.caller) + r), aq), IntegerEntry(s, as)]
177+                }
178+        }
179+
180+
181+
182+@Callable(W)
183+func withdrawENNO (at) = if (!(y))
184+    then throw("DApp is inactive at this moment")
185+    else if ((0 >= at))
186+        then throw("withdrawAmount <= 0")
187+        else {
188+            let ar = F()
189+            let ae = D(W.caller)
190+            if ((at > ar))
191+                then throw("withdrawAmount is more than available to withdraw")
192+                else if ((at > ae))
193+                    then throw("You are trying to unstake more than you have staked.")
194+                    else {
195+                        let as = (ar - at)
196+                        let au = (ae - at)
197+[IntegerEntry((toString(W.caller) + r), au), IntegerEntry(s, as), ScriptTransfer(W.caller, at, A)]
198+                        }
199+            }
200+
201+
202+
203+@Callable(W)
204+func claimAndWithdrawENNO () = if (!(y))
205+    then throw("DApp is inactive at this moment")
206+    else {
207+        let av = J(W.originCaller)
208+        let aw = P(W.originCaller)
209+        let ax = (av - aw)
210+        let ar = F()
211+        if ((ax > ar))
212+            then throw("claimAmount is more than available to withdraw")
213+            else if ((0 >= ax))
214+                then throw("Claim amount must be bigger than 0")
215+                else {
216+                    let ay = (aw + ax)
217+[IntegerEntry((toString(W.originCaller) + v), ay), IntegerEntry((toString(W.originCaller) + w), ax), ScriptTransfer(W.originCaller, ax, A)]
218+                    }
219+        }
220+
221+
222+
223+@Callable(W)
224+func claimAndStakeENNO () = if (!(y))
225+    then throw("DApp is inactive at this moment")
226+    else {
227+        let av = J(W.originCaller)
228+        let aw = P(W.originCaller)
229+        let ax = (av - aw)
230+        if ((0 >= ax))
231+            then throw("Claim amount must be bigger than 0")
232+            else {
233+                let ay = (aw + ax)
234+                let ae = D(W.originCaller)
235+                let aq = (ae + ax)
236+                let ar = F()
237+                let as = (ar + ax)
238+[IntegerEntry((toString(W.originCaller) + r), aq), IntegerEntry((toString(W.originCaller) + v), ay), IntegerEntry((toString(W.originCaller) + w), ax), IntegerEntry(s, as)]
239+                }
240+        }
241+
242+
243+
244+@Callable(W)
245+func shutdown () = if (!(y))
246+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, f), "the cause wasn't specified")))
247+    else if (!(containsElement([a, b, c, d], W.callerPublicKey)))
248+        then throw("Only admin can call this function")
249+        else B("Paused by admin")
250+
251+
252+
253+@Callable(W)
254+func activate () = if (y)
255+    then throw("DApp is already active")
256+    else if (!(containsElement([a, b, c, d], W.callerPublicKey)))
257+        then throw("Only admin can call this function")
258+        else [BooleanEntry(e, true), DeleteEntry(f)]
259+
260+
261+@Verifier(az)
262+func aA () = {
263+    let aB = if (sigVerify(az.bodyBytes, az.proofs[0], a))
264+        then 1
265+        else 0
266+    let aC = if (sigVerify(az.bodyBytes, az.proofs[1], b))
267+        then 1
268+        else 0
269+    let aD = if (sigVerify(az.bodyBytes, az.proofs[2], c))
270+        then 1
271+        else 0
272+    (((aB + aC) + aD) >= 2)
273+    }
274+
github/deemru/w8io/169f3d6 
23.17 ms ◑