tx · BvNMntVJ1wdcRMCMXYeMDGSjHA9eDpcwknEGqwrjMBBD

3MxovCV2pBS5Z6YEcj3Gap5ish6dX3YERfP:  -0.01000000 Waves

2022.11.09 20:16 [2309889] smart account 3MxovCV2pBS5Z6YEcj3Gap5ish6dX3YERfP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BvNMntVJ1wdcRMCMXYeMDGSjHA9eDpcwknEGqwrjMBBD",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1668014249572,
    "version": 2,
    "chainId": 84,
    "sender": "3MxovCV2pBS5Z6YEcj3Gap5ish6dX3YERfP",
    "senderPublicKey": "6aZUzHaTgW7zPizjKqNFNAaKdYXVUaNwstd6E3NsD3YF",
    "proofs": [
        "2KP4wbAVTLAnYCtbn4ESsPJqX9zmrBZxCoCZpCGrHCpeSNWPN8Nr9JTqbpEseCXFHkA4M4mcZtaKJVGoXy1HcFaS"
    ],
    "script": "base64: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",
    "height": 2309889,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: mKTDV39acEKVnuZwHoV7AFvZpFVAPPNkaT1MTBidUGL

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let precision = 1000000000000000000
5+
6+func keyManagerPublicKey () = getString("managerPublicKey")
7+
8+
9+func managerPublicKeyOrUnit () = match keyManagerPublicKey() {
10+    case s: String => 
11+        fromBase58String(s)
12+    case _: Unit => 
13+        unit
14+    case _ => 
15+        throw("Match error")
16+}
17+
18+
19+func mustManager (i) = {
20+    let pd = throw("permission denied")
21+    match managerPublicKeyOrUnit() {
22+        case pk: ByteVector => 
23+            if ((i.callerPublicKey == pk))
24+                then true
25+                else pd
26+        case _: Unit => 
27+            if ((i.caller == this))
28+                then true
29+                else pd
30+        case _ => 
31+            throw("Match error")
32+    }
33+    }
34+
35+
36+func mustNotInited () = match getBoolean("inited") {
37+    case inited: Boolean => 
38+        if ((inited == false))
39+            then true
40+            else throw("Already inited")
41+    case _: Unit => 
42+        false
43+    case _ => 
44+        throw("Match error")
45+}
46+
47+
48+func cancelLease () = match getBinary("leaseId") {
49+    case id: ByteVector => 
50+[LeaseCancel(id), DeleteEntry("leaseId")]
51+    case _: Unit => 
52+        nil
53+    case _ => 
54+        throw("Match error")
55+}
56+
57+
58+func getBalance () = valueOrElse(getInteger("balance"), 0)
59+
60+
61+func setBalance (amount) = IntegerEntry("balance", amount)
62+
63+
64+func lease (amount) = if ((amount == 0))
65+    then nil
66+    else {
67+        let leaserAddress = Address(fromBase58String(getStringValue("leaserAddress")))
68+        let currentAmount = getBalance()
69+        let newAmount = (currentAmount + amount)
70+        let leaseActions = if ((newAmount > 0))
71+            then {
72+                let newLease = Lease(leaserAddress, newAmount)
73+                let newLeaseId = calculateLeaseId(newLease)
74+[newLease, BinaryEntry("leaseId", newLeaseId)]
75+                }
76+            else nil
77+        ((cancelLease() ++ leaseActions) :+ setBalance(newAmount))
78+        }
79+
80+
81+func issueSWaves (amount) = {
82+    let sWavesAssetId = fromBase58String(getStringValue("sWavesAssetId"))
83+    Reissue(sWavesAssetId, amount, true)
84+    }
85+
86+
87+func burnSWaves (amount) = {
88+    let sWavesAssetId = fromBase58String(getStringValue("sWavesAssetId"))
89+    Burn(sWavesAssetId, amount)
90+    }
91+
92+
93+func sendSWaves (recipient,amount) = {
94+    let sWavesAssetId = fromBase58String(getStringValue("sWavesAssetId"))
95+    ScriptTransfer(recipient, amount, sWavesAssetId)
96+    }
97+
98+
99+func sendWaves (recipient,amount) = ScriptTransfer(recipient, amount, unit)
100+
101+
102+func sWavesQuantity () = {
103+    let assetId = fromBase58String(getStringValue("sWavesAssetId"))
104+    match assetInfo(assetId) {
105+        case asset: Asset => 
106+            asset.quantity
107+        case _ => 
108+            throw("Can't find asset")
109+    }
110+    }
111+
112+
113+func getExcessWaves () = {
114+    let leaserAddress = Address(fromBase58String(getStringValue("leaserAddress")))
115+    wavesBalance(leaserAddress).regular
116+    }
117+
118+
119+func setRate (rate,growthRate) = [IntegerEntry("lastRate", rate), IntegerEntry("lastTimestamp", lastBlock.timestamp)]
120+
121+
122+func withdraw () = {
123+    let minerAddress = Address(fromBase58String(getStringValue("leaserAddress")))
124+    let result = invoke(minerAddress, "withdraw", nil, nil)
125+    if ((result == result))
126+        then result
127+        else throw("Strict value is not equal to itself.")
128+    }
129+
130+
131+func currentRate (dt) = (getIntegerValue("lastRate") + (getIntegerValue("growthRate") * dt))
132+
133+
134+func getCompoundTimestampDiff () = (lastBlock.timestamp - getIntegerValue("lastTimestamp"))
135+
136+
137+@Callable(i)
138+func compound () = {
139+    let dt = getCompoundTimestampDiff()
140+    if ((dt == 0))
141+        then nil
142+        else {
143+            let rate = currentRate(dt)
144+            let excessWaves = getExcessWaves()
145+            let sWavesTotal = sWavesQuantity()
146+            let growthRate = (fraction(excessWaves, precision, sWavesTotal) / dt)
147+            let withdrawResult = withdraw()
148+            if ((withdrawResult == withdrawResult))
149+                then (lease(excessWaves) ++ setRate(rate, growthRate))
150+                else throw("Strict value is not equal to itself.")
151+            }
152+    }
153+
154+
155+
156+@Callable(i)
157+func init (leaserAddress) = {
158+    let checks = [mustManager(i), mustNotInited()]
159+    if ((checks == checks))
160+        then {
161+            let sWaves = Issue("sWaves", "", 0, 8, true, unit, 0)
162+            let sWavesAssetId = calculateAssetId(sWaves)
163+[BooleanEntry("inited", true), StringEntry("sWavesAssetId", toBase58String(sWavesAssetId)), StringEntry("leaserAddress", leaserAddress), IntegerEntry("lastRate", precision), IntegerEntry("lastTimestamp", lastBlock.timestamp), IntegerEntry("growthRate", 0), IntegerEntry("balance", 0), sWaves]
164+            }
165+        else throw("Strict value is not equal to itself.")
166+    }
167+
168+
169+
170+@Callable(i)
171+func stake () = {
172+    let payment = i.payments[0]
173+    if ((payment.assetId != unit))
174+        then throw("Only WAVES supported")
175+        else if ((size(i.payments) != 1))
176+            then throw("Wrong payments amount")
177+            else {
178+                let dt = getCompoundTimestampDiff()
179+                let rate = currentRate(dt)
180+                let toReissue = fraction(payment.amount, precision, rate)
181+                let result = invoke(this, "compound", nil, nil)
182+                if ((result == result))
183+                    then ((lease(payment.amount) :+ issueSWaves(toReissue)) :+ sendSWaves(i.caller, toReissue))
184+                    else throw("Strict value is not equal to itself.")
185+                }
186+    }
187+
188+
189+
190+@Callable(i)
191+func unstake () = {
192+    let payment = i.payments[0]
193+    let sWavesAssetId = fromBase58String(getStringValue("sWavesAssetId"))
194+    if ((payment.assetId != sWavesAssetId))
195+        then throw("Only sWAVES supported")
196+        else if ((size(i.payments) != 1))
197+            then throw("Wrong payments amount")
198+            else {
199+                let dt = getCompoundTimestampDiff()
200+                let rate = currentRate(dt)
201+                let transferAmount = fraction(payment.amount, rate, precision)
202+                let result = invoke(this, "compound", nil, nil)
203+                if ((result == result))
204+                    then ((lease(-(transferAmount)) :+ burnSWaves(payment.amount)) :+ sendWaves(i.caller, transferAmount))
205+                    else throw("Strict value is not equal to itself.")
206+                }
207+    }
208+
209+
210+@Verifier(tx)
211+func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
212+
github/deemru/w8io/169f3d6 
23.07 ms ◑