tx · E4EFZNmyZQ2Nof4on2PQMEDEpcACi7B5nw1hFsLCwuNd

3PJ6BKNEdH6mtdNyUhnBbqrGz3GGywz2h5f:  -0.14000000 Waves

2021.10.29 09:42 [2832262] smart account 3PJ6BKNEdH6mtdNyUhnBbqrGz3GGywz2h5f > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "E4EFZNmyZQ2Nof4on2PQMEDEpcACi7B5nw1hFsLCwuNd",
    "fee": 14000000,
    "feeAssetId": null,
    "timestamp": 1635489745806,
    "version": 2,
    "chainId": 87,
    "sender": "3PJ6BKNEdH6mtdNyUhnBbqrGz3GGywz2h5f",
    "senderPublicKey": "Eaf4FwUufqN2GjEDu6h1w8UT5zB58jCghAoQRg1H3Pv1",
    "proofs": [
        "58Hiz32gBhgkGGHLeFWjDLrQD9yfRUPA6auAMjjZWCYQyiDjr3fgMTo73B2rUXyAbMKkpdAp9QwXJ7tjK7TXhgH8"
    ],
    "script": "base64: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",
    "height": 2832262,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: TWan5v11bdfqrFGvtPjsq8MW4kbLkFD9cmJ7GckLxcQ

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let adminPubKey1 = base58'Eaf4FwUufqN2GjEDu6h1w8UT5zB58jCghAoQRg1H3Pv1'
5+
6+let adminPubKey2 = base58'Eaf4FwUufqN2GjEDu6h1w8UT5zB58jCghAoQRg1H3Pv1'
7+
8+let adminPubKey3 = base58'Eaf4FwUufqN2GjEDu6h1w8UT5zB58jCghAoQRg1H3Pv1'
9+
10+let adminPubKeyStartStop = base58'Eaf4FwUufqN2GjEDu6h1w8UT5zB58jCghAoQRg1H3Pv1'
11+
12+let keyActive = "active"
13+
14+let keyCause = "shutdown_cause"
15+
16+let keyUserENNOLocked = "_ENNO_amount"
17+
18+let keyTotalENNOLocked = "total_ENNO_amount"
19+
20+let keyUserENNOClaimedAmount = "_ENNO_claimed_amount"
21+
22+let keyUserENNOLastClaimedAmount = "_ENNO_last_claimed_amount"
23+
24+let keyUserENNOLockedTag = "share_"
25+
26+let isActive = valueOrElse(getBoolean(this, keyActive), true)
27+
28+let shareData = base58'8PYLQhGnktNwGZo5AKLxwBLnAvUc25v4Cw52ihHM6iyE'
29+
30+let ENNO = base58'7LMV3s1J4dKpMQZqge5sKYoFkZRLojnnU49aerqos4yg'
31+
32+func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
33+
34+
35+func getUserENNOLocked (user) = valueOrElse(getInteger(this, (toString(user) + keyUserENNOLocked)), 0)
36+
37+
38+func getTotalENNOLocked () = valueOrElse(getInteger(this, keyTotalENNOLocked), 0)
39+
40+
41+func getCallerShare (caller) = {
42+    let callerShare = getInteger(addressFromPublicKey(shareData), (keyUserENNOLockedTag + toString(caller)))
43+    let callerShareAmount =     match callerShare {
44+        case share: Int => 
45+            share
46+        case share: Unit => 
47+            throw("Only governance qualifiers can call this function.")
48+        case _ => 
49+            throw("Match error")
50+    }
51+    callerShareAmount
52+    }
53+
54+
55+func getClaimedAmount (caller) = {
56+    let callerWithdrawn = getInteger(this, (toString(caller) + keyUserENNOClaimedAmount))
57+    let callerWithdrawnAmount =     match callerWithdrawn {
58+        case share: Int => 
59+            share
60+        case share: Unit => 
61+            0
62+        case _ => 
63+            throw("Match error")
64+    }
65+    callerWithdrawnAmount
66+    }
67+
68+
69+@Callable(i)
70+func lockENNO () = if (!(isActive))
71+    then throw("DApp is inactive at this moment")
72+    else {
73+        let $t018971972 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
74+        let pmtAmount = $t018971972._1
75+        let pmtAssetId = $t018971972._2
76+        if ((pmtAssetId != ENNO))
77+            then throw("Incorrect payment assetId only Enno Cash is allowed.")
78+            else {
79+                let userENNOLocked = getUserENNOLocked(i.caller)
80+                let userENNOLockedNew = (userENNOLocked + pmtAmount)
81+                let totalENNOLocked = getTotalENNOLocked()
82+                let totalENNOLockedNew = (totalENNOLocked + pmtAmount)
83+[IntegerEntry((toString(i.caller) + keyUserENNOLocked), userENNOLockedNew), IntegerEntry(keyTotalENNOLocked, totalENNOLockedNew)]
84+                }
85+        }
86+
87+
88+
89+@Callable(i)
90+func withdrawENNO (withdrawAmount) = if (!(isActive))
91+    then throw("DApp is inactive at this moment")
92+    else if ((0 >= withdrawAmount))
93+        then throw("withdrawAmount <= 0")
94+        else {
95+            let totalENNOLocked = getTotalENNOLocked()
96+            let userENNOLocked = getUserENNOLocked(i.caller)
97+            if ((withdrawAmount > totalENNOLocked))
98+                then throw("withdrawAmount is more than available to withdraw")
99+                else if ((withdrawAmount > userENNOLocked))
100+                    then throw("You are trying to unstake more than you have staked.")
101+                    else {
102+                        let totalENNOLockedNew = (totalENNOLocked - withdrawAmount)
103+                        let userENNOamountNew = (userENNOLocked - withdrawAmount)
104+[IntegerEntry((toString(i.caller) + keyUserENNOLocked), userENNOamountNew), IntegerEntry(keyTotalENNOLocked, totalENNOLockedNew), ScriptTransfer(i.caller, withdrawAmount, ENNO)]
105+                        }
106+            }
107+
108+
109+
110+@Callable(i)
111+func claimAndWithdrawENNO () = if (!(isActive))
112+    then throw("DApp is inactive at this moment")
113+    else {
114+        let userShare = getCallerShare(i.originCaller)
115+        let userClaimedAmount = getClaimedAmount(i.originCaller)
116+        let claimAmount = (userShare - userClaimedAmount)
117+        let totalENNOLocked = getTotalENNOLocked()
118+        if ((claimAmount > totalENNOLocked))
119+            then throw("claimAmount is more than available to withdraw")
120+            else if ((0 >= claimAmount))
121+                then throw("Claim amount must be bigger than 0")
122+                else {
123+                    let userClaimedAmountNew = (userClaimedAmount + claimAmount)
124+[IntegerEntry((toString(i.originCaller) + keyUserENNOClaimedAmount), userClaimedAmountNew), IntegerEntry((toString(i.originCaller) + keyUserENNOLastClaimedAmount), claimAmount), ScriptTransfer(i.originCaller, claimAmount, ENNO)]
125+                    }
126+        }
127+
128+
129+
130+@Callable(i)
131+func claimAndStakeENNO () = if (!(isActive))
132+    then throw("DApp is inactive at this moment")
133+    else {
134+        let userShare = getCallerShare(i.originCaller)
135+        let userClaimedAmount = getClaimedAmount(i.originCaller)
136+        let claimAmount = (userShare - userClaimedAmount)
137+        if ((0 >= claimAmount))
138+            then throw("Claim amount must be bigger than 0")
139+            else {
140+                let userClaimedAmountNew = (userClaimedAmount + claimAmount)
141+                let userENNOLocked = getUserENNOLocked(i.originCaller)
142+                let userENNOLockedNew = (userENNOLocked + claimAmount)
143+                let totalENNOLocked = getTotalENNOLocked()
144+                let totalENNOLockedNew = (totalENNOLocked + claimAmount)
145+[IntegerEntry((toString(i.originCaller) + keyUserENNOLocked), userENNOLockedNew), IntegerEntry((toString(i.originCaller) + keyUserENNOClaimedAmount), userClaimedAmountNew), IntegerEntry((toString(i.originCaller) + keyUserENNOLastClaimedAmount), claimAmount), IntegerEntry(keyTotalENNOLocked, totalENNOLockedNew)]
146+                }
147+        }
148+
149+
150+
151+@Callable(i)
152+func shutdown () = if (!(isActive))
153+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, keyCause), "the cause wasn't specified")))
154+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
155+        then throw("Only admin can call this function")
156+        else suspend("Paused by admin")
157+
158+
159+
160+@Callable(i)
161+func activate () = if (isActive)
162+    then throw("DApp is already active")
163+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
164+        then throw("Only admin can call this function")
165+        else [BooleanEntry(keyActive, true), DeleteEntry(keyCause)]
166+
167+
168+@Verifier(tx)
169+func verify () = {
170+    let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
171+        then 1
172+        else 0
173+    let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
174+        then 1
175+        else 0
176+    let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
177+        then 1
178+        else 0
179+    (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
180+    }
181+
github/deemru/w8io/3ef1775 
29.08 ms ◑