tx · 7hi7fjj3MYWkx7c4XwMsF4DJx8giGaTsA5bW88wPCPJf

3MsN1Q6UqKokdBUxv9Azrh5CGSAQ3UQzTsu:  -0.01000000 Waves

2022.11.11 18:17 [2312656] smart account 3MsN1Q6UqKokdBUxv9Azrh5CGSAQ3UQzTsu > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7hi7fjj3MYWkx7c4XwMsF4DJx8giGaTsA5bW88wPCPJf",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1668179858414,
    "version": 2,
    "chainId": 84,
    "sender": "3MsN1Q6UqKokdBUxv9Azrh5CGSAQ3UQzTsu",
    "senderPublicKey": "HQMMqTQiHWTyhMbuUsTXeJgjtwqJQGUwCL4VabSaAEeh",
    "proofs": [
        "3yQL1hVVuVj2QNAgJpmbwuqfpL97QsNL2ZXXG862r8Fe6WXEnJeaj2xEQpobfsLBw337Nzp8hVys9fisdUDiibM3"
    ],
    "script": "base64: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",
    "height": 2312656,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 53NEFeuFxAzaJ4hDn6n5RDBxW6FFwDLbbki8iSDszUPq

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let PRECISION = 1000000000000000000
5+
6+let DURATION = ((60 * 60) * 24)
7+
8+let DECIMALS = 100000000
9+
10+let k_lastCompoundTime = "k_lastCompoundTime"
11+
12+let k_periodFinish = "k_periodFinish"
13+
14+let k_lastRate = "k_lastRate"
15+
16+let k_growthRate = "k_growthRate"
17+
18+let k_balance = "k_balance"
19+
20+let k_leaseId = "k_leaseId"
21+
22+let k_initialized = "k_initialized"
23+
24+let k_adminPublicKey = "k_adminPublicKey"
25+
26+let k_adminAddress = "k_adminAddress"
27+
28+let k_minerAddress = "k_minerAddress"
29+
30+let k_sWavesAsset = "k_sWavesAssetId"
31+
32+func divd (_x,_y) = fraction(_x, DECIMALS, _y, HALFEVEN)
33+
34+
35+func muld (_x,_y) = fraction(_x, _y, DECIMALS, HALFEVEN)
36+
37+
38+func divp (_x,_y) = fraction(_x, PRECISION, _y, HALFEVEN)
39+
40+
41+func mulp (_x,_y) = fraction(_x, _y, PRECISION, HALFEVEN)
42+
43+
44+func abs (_x) = if ((_x > 0))
45+    then _x
46+    else -(_x)
47+
48+
49+func minv (_x,_y) = if ((_x > _y))
50+    then _y
51+    else _x
52+
53+
54+func toCompositeKey (_key,_address) = ((_key + "_") + _address)
55+
56+
57+func adminAddress () = addressFromString(getStringValue(this, k_adminAddress))
58+
59+
60+func adminPublicKey () = fromBase58String(getStringValue(this, k_adminPublicKey))
61+
62+
63+func minerAddress () = valueOrErrorMessage(addressFromString(getStringValue(this, k_minerAddress)), "Invalid miner address is not set")
64+
65+
66+func sWavesAsset () = fromBase58String(getStringValue(this, k_sWavesAsset))
67+
68+
69+func initialized () = valueOrElse(getBoolean(this, k_initialized), false)
70+
71+
72+func int (k) = valueOrErrorMessage(getInteger(this, k), ("No value for " + k))
73+
74+
75+func int0 (k) = valueOrElse(getInteger(this, k), 0)
76+
77+
78+func lastCompoundTime () = int0(k_lastCompoundTime)
79+
80+
81+func growthRate () = int0(k_growthRate)
82+
83+
84+func balance () = int0(k_balance)
85+
86+
87+func lastRate () = int(k_lastRate)
88+
89+
90+func periodFinish () = int0(k_periodFinish)
91+
92+
93+func adminPublicKeyOrUnit () = match getString(this, k_adminPublicKey) {
94+    case s: String => 
95+        fromBase58String(s)
96+    case _: Unit => 
97+        unit
98+    case _ => 
99+        throw("Match error")
100+}
101+
102+
103+func mustAdmin (i) = {
104+    let pd = throw("permission denied")
105+    match adminPublicKeyOrUnit() {
106+        case pk: ByteVector => 
107+            if ((i.callerPublicKey == pk))
108+                then true
109+                else pd
110+        case _: Unit => 
111+            if ((i.caller == this))
112+                then true
113+                else pd
114+        case _ => 
115+            throw("Match error")
116+    }
117+    }
118+
119+
120+func currentTimestampSec () = (lastBlock.timestamp / 1000)
121+
122+
123+func dt () = minv(currentTimestampSec(), periodFinish())
124+
125+
126+func cancelLease () = match getBinary(k_leaseId) {
127+    case id: ByteVector => 
128+[LeaseCancel(id), DeleteEntry(k_leaseId)]
129+    case _: Unit => 
130+        nil
131+    case _ => 
132+        throw("Match error")
133+}
134+
135+
136+func updateBalance (_amount) = [IntegerEntry(k_balance, _amount)]
137+
138+
139+func updateTime (_lastCompoundTime,_periodFinish) = [IntegerEntry(k_lastCompoundTime, _lastCompoundTime), IntegerEntry(k_periodFinish, _periodFinish)]
140+
141+
142+func updateRate (_rate,_growthRate) = [IntegerEntry(k_lastRate, _rate), IntegerEntry(k_growthRate, _growthRate)]
143+
144+
145+func updateLease (_amount) = if ((_amount > 0))
146+    then {
147+        let newLease = Lease(minerAddress(), _amount)
148+        let newLeaseId = calculateLeaseId(newLease)
149+[newLease, BinaryEntry(k_leaseId, newLeaseId)]
150+        }
151+    else nil
152+
153+
154+func lease (_amount) = if ((_amount == 0))
155+    then nil
156+    else {
157+        let newAmount = (balance() + _amount)
158+        ((cancelLease() ++ updateLease(newAmount)) ++ updateBalance(newAmount))
159+        }
160+
161+
162+func issueSWaves (_amount) = [Reissue(sWavesAsset(), _amount, true)]
163+
164+
165+func burnSWaves (_amount) = [Burn(sWavesAsset(), _amount)]
166+
167+
168+func sendSWaves (_recipient,_amount) = [ScriptTransfer(_recipient, _amount, sWavesAsset())]
169+
170+
171+func sendWaves (_recipient,_amount) = [ScriptTransfer(_recipient, _amount, unit)]
172+
173+
174+func sWavesQuantity () = match assetInfo(sWavesAsset()) {
175+    case asset: Asset => 
176+        asset.quantity
177+    case _ => 
178+        throw("Can't find asset")
179+}
180+
181+
182+func getExcessWaves () = wavesBalance(minerAddress()).regular
183+
184+
185+func withdraw () = {
186+    let result = invoke(minerAddress(), "withdraw", nil, nil)
187+    if ((result == result))
188+        then result
189+        else throw("Strict value is not equal to itself.")
190+    }
191+
192+
193+func currentRate () = (lastRate() + (growthRate() * dt()))
194+
195+
196+@Callable(i)
197+func init (_minerAddress) = {
198+    let check = mustAdmin(i)
199+    if ((check == check))
200+        then if (initialized())
201+            then throw("Already initialized")
202+            else {
203+                let sWaves = Issue("sWaves", "", 0, 8, true, unit, 0)
204+                let sWavesAssetId = calculateAssetId(sWaves)
205+[BooleanEntry(k_initialized, true), StringEntry(k_sWavesAsset, toBase58String(sWavesAssetId)), StringEntry(k_minerAddress, _minerAddress), IntegerEntry(k_lastRate, PRECISION), sWaves]
206+                }
207+        else throw("Strict value is not equal to itself.")
208+    }
209+
210+
211+
212+@Callable(i)
213+func compound () = {
214+    let excessWaves = getExcessWaves()
215+    if ((excessWaves == excessWaves))
216+        then if (((1 * DECIMALS) > excessWaves))
217+            then nil
218+            else {
219+                let doWithdraw = withdraw()
220+                if ((doWithdraw == doWithdraw))
221+                    then {
222+                        let newRate = currentRate()
223+                        let timestamp = currentTimestampSec()
224+                        let newGrowthRate = if ((timestamp > periodFinish()))
225+                            then (excessWaves / DURATION)
226+                            else {
227+                                let remainingTime = (periodFinish() - timestamp)
228+                                let leftover = (growthRate() * remainingTime)
229+                                ((excessWaves + leftover) / DURATION)
230+                                }
231+                        ((lease(excessWaves) ++ updateRate(newRate, newGrowthRate)) ++ updateTime(timestamp, (timestamp + DURATION)))
232+                        }
233+                    else throw("Strict value is not equal to itself.")
234+                }
235+        else throw("Strict value is not equal to itself.")
236+    }
237+
238+
239+
240+@Callable(i)
241+func stake () = {
242+    let doCompound = invoke(this, "compound", nil, nil)
243+    if ((doCompound == doCompound))
244+        then {
245+            let payment = i.payments[0]
246+            if ((payment.assetId != unit))
247+                then throw("Only WAVES supported")
248+                else if ((size(i.payments) != 1))
249+                    then throw("Wrong payments amount")
250+                    else {
251+                        let rate = currentRate()
252+                        let toReissue = divp(payment.amount, rate)
253+                        ((lease(payment.amount) ++ issueSWaves(toReissue)) ++ sendSWaves(i.caller, toReissue))
254+                        }
255+            }
256+        else throw("Strict value is not equal to itself.")
257+    }
258+
259+
260+
261+@Callable(i)
262+func unstake () = {
263+    let doCompound = invoke(this, "compound", nil, nil)
264+    if ((doCompound == doCompound))
265+        then {
266+            let payment = i.payments[0]
267+            if ((payment.assetId != sWavesAsset()))
268+                then throw("Only sWAVES supported")
269+                else if ((size(i.payments) != 1))
270+                    then throw("Wrong payments amount")
271+                    else {
272+                        let rate = currentRate()
273+                        let transferAmount = mulp(payment.amount, rate)
274+                        ((lease(-(transferAmount)) ++ burnSWaves(payment.amount)) ++ sendWaves(i.caller, transferAmount))
275+                        }
276+            }
277+        else throw("Strict value is not equal to itself.")
278+    }
279+
280+
281+@Verifier(tx)
282+func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
283+
github/deemru/w8io/3ef1775 
28.27 ms ◑