tx · GFJuSYFo2r5W5gyztUWenFpxTcD4BxxQAtvAGoQ1CoW8

3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz:  -0.01400000 Waves

2022.05.04 16:02 [2036979] smart account 3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GFJuSYFo2r5W5gyztUWenFpxTcD4BxxQAtvAGoQ1CoW8",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1651669417249,
    "version": 1,
    "sender": "3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz",
    "senderPublicKey": "E7cYpzqL1fF9VQjL3m4zr3xXfV289rCkrfE2fJyAHMqR",
    "proofs": [
        "5nAd9KFujACd5oYHdPkmu1YbYNKuSNxyhqJsKgKdGPdwv1vKDguiZbrrN1Dd9KehuCfFe2UHGKx1cfDJfGB7WT7Q"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2036979,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 2N7vhN6jBWpR38ucttgJjCUxjp2TsfVz17HD1iPN8nCr

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+func keyManagerPublicKey () = "%s__managerPublicKey"
7+
8+
9+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
10+
11+
12+func keyUser (address) = makeString(["%s", address], SEP)
13+
14+
15+func keyRevoked (address) = makeString(["%s", "revoked", address], SEP)
16+
17+
18+func keyUserVestingStart (address) = makeString(["%s", "vestingStart", address], SEP)
19+
20+
21+func keyUserVestingEnd (address) = makeString(["%s", "vestingEnd", address], SEP)
22+
23+
24+func keyUserAmountPerBlock (address) = makeString(["%s", "amountPerBlock", address], SEP)
25+
26+
27+func keyWxAssetId () = makeString(["%s", "wxAssetId"], SEP)
28+
29+
30+func throwErr (msg) = throw(makeString(["vesting.ride:", msg], " "))
31+
32+
33+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
34+    case s: String => 
35+        fromBase58String(s)
36+    case _: Unit => 
37+        unit
38+    case _ => 
39+        throw("Match error")
40+}
41+
42+
43+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
44+    case s: String => 
45+        fromBase58String(s)
46+    case _: Unit => 
47+        unit
48+    case _ => 
49+        throw("Match error")
50+}
51+
52+
53+func mustManager (i) = {
54+    let pd = throwErr("permission denied")
55+    match managerPublicKeyOrUnit() {
56+        case pk: ByteVector => 
57+            if ((i.callerPublicKey == pk))
58+                then true
59+                else pd
60+        case _: Unit => 
61+            if ((i.caller == this))
62+                then true
63+                else pd
64+        case _ => 
65+            throw("Match error")
66+    }
67+    }
68+
69+
70+func valueUserS (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = makeString(["%d%d%d%d%d", totalAmount, remainingAmount, "0", claimedWXAmount, lastClaimedHeight], SEP)
71+
72+
73+func valueUser (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = valueUserS(toString(totalAmount), toString(remainingAmount), toString(claimedWXAmount), toString(lastClaimedHeight))
74+
75+
76+func getUserTotalAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[1])
77+
78+
79+func getUserRemainingAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[2])
80+
81+
82+func getUserClaimedAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[3])
83+
84+
85+func getUserLastClaimedHeight (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[5])
86+
87+
88+func availableToClaimNow (address) = {
89+    let lastHeight = getUserLastClaimedHeight(address)
90+    if ((lastHeight >= height))
91+        then 0
92+        else {
93+            let end = value(getInteger(keyUserVestingEnd(address)))
94+            if ((height > end))
95+                then getUserRemainingAmount(address)
96+                else {
97+                    let unclaimedPeriod = (height - lastHeight)
98+                    (value(getInteger(keyUserAmountPerBlock(address))) * unclaimedPeriod)
99+                    }
100+            }
101+    }
102+
103+
104+@Callable(i)
105+func constructor (wxAssetId) = {
106+    let check = mustManager(i)
107+    if ((check == check))
108+        then [StringEntry(keyWxAssetId(), wxAssetId)]
109+        else throw("Strict value is not equal to itself.")
110+    }
111+
112+
113+
114+@Callable(i)
115+func createDepositFor (address,blocksDuration) = {
116+    let endHeight = (height + blocksDuration)
117+    let checks = [mustManager(i), if ((endHeight > height))
118+        then true
119+        else throwErr("endHeight must be more than height"), if ((getString(keyUser(address)) == unit))
120+        then true
121+        else throwErr("deposit for user already exists"), if ((toBase58String(value(i.payments[0].assetId)) == value(getString(keyWxAssetId()))))
122+        then true
123+        else throwErr("attached payment is not WX")]
124+    if ((checks == checks))
125+        then {
126+            let amount = i.payments[0].amount
127+            let vestingLen = (endHeight - height)
128+[StringEntry(keyUser(address), valueUser(amount, amount, 0, height)), IntegerEntry(keyUserVestingStart(address), height), IntegerEntry(keyUserVestingEnd(address), endHeight), IntegerEntry(keyUserAmountPerBlock(address), (amount / vestingLen))]
129+            }
130+        else throw("Strict value is not equal to itself.")
131+    }
132+
133+
134+
135+@Callable(i)
136+func revokeDepositFor (address) = {
137+    let checks = [mustManager(i), if ((getString(keyUser(address)) != unit))
138+        then true
139+        else throwErr("deposit for user is not exists")]
140+    if ((checks == checks))
141+        then {
142+            let totalAmount = getUserTotalAmount(address)
143+            let amount = availableToClaimNow(address)
144+            let claimedWXAmount = getUserClaimedAmount(address)
145+            let lastClaimedHeight = getUserLastClaimedHeight(address)
146+[BooleanEntry(keyRevoked(address), true), StringEntry(keyUser(address), valueUser(totalAmount, amount, claimedWXAmount, lastClaimedHeight))]
147+            }
148+        else throw("Strict value is not equal to itself.")
149+    }
150+
151+
152+
153+@Callable(i)
154+func claim () = {
155+    let addr = i.caller
156+    let addrStr = toString(addr)
157+    let wx = fromBase58String(value(getString(keyWxAssetId())))
158+    let amount = availableToClaimNow(addrStr)
159+    let ensureAmount = if ((amount != 0))
160+        then true
161+        else throwErr("nothing to claim")
162+    if ((ensureAmount == ensureAmount))
163+        then {
164+            let totalAmount = getUserTotalAmount(addrStr)
165+            let remainingAmount = getUserRemainingAmount(addrStr)
166+            let claimedWXAmount = getUserClaimedAmount(addrStr)
167+            let isRevokedUser = valueOrElse(getBoolean(keyRevoked(addrStr)), false)
168+            if (isRevokedUser)
169+                then [ScriptTransfer(addr, remainingAmount, wx), StringEntry(keyUser(addrStr), valueUser(totalAmount, 0, (claimedWXAmount + remainingAmount), height))]
170+                else [ScriptTransfer(addr, amount, wx), StringEntry(keyUser(addrStr), valueUser(totalAmount, (remainingAmount - amount), (claimedWXAmount + amount), height))]
171+            }
172+        else throw("Strict value is not equal to itself.")
173+    }
174+
175+
176+
177+@Callable(i)
178+func claimREADONLY (address) = {
179+    let amount = availableToClaimNow(address)
180+    $Tuple2(nil, amount)
181+    }
182+
183+
184+
185+@Callable(i)
186+func stats (address) = $Tuple2(nil, [value(getInteger(keyUserVestingStart(address))), value(getInteger(keyUserVestingEnd(address))), getUserTotalAmount(address), getUserClaimedAmount(address), getUserRemainingAmount(address), availableToClaimNow(address)])
187+
188+
189+
190+@Callable(i)
191+func setManager (pendingManagerPublicKey) = {
192+    let checkCaller = mustManager(i)
193+    if ((checkCaller == checkCaller))
194+        then {
195+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
196+            if ((checkManagerPublicKey == checkManagerPublicKey))
197+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
198+                else throw("Strict value is not equal to itself.")
199+            }
200+        else throw("Strict value is not equal to itself.")
201+    }
202+
203+
204+
205+@Callable(i)
206+func confirmManager () = {
207+    let pm = pendingManagerPublicKeyOrUnit()
208+    let hasPM = if (isDefined(pm))
209+        then true
210+        else throwErr("no pending manager")
211+    if ((hasPM == hasPM))
212+        then {
213+            let checkPM = if ((i.callerPublicKey == value(pm)))
214+                then true
215+                else throwErr("you are not pending manager")
216+            if ((checkPM == checkPM))
217+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
218+                else throw("Strict value is not equal to itself.")
219+            }
220+        else throw("Strict value is not equal to itself.")
221+    }
222+
223+
224+@Verifier(tx)
225+func verify () = {
226+    let targetPublicKey =     match managerPublicKeyOrUnit() {
227+        case pk: ByteVector => 
228+            pk
229+        case _: Unit => 
230+            tx.senderPublicKey
231+        case _ => 
232+            throw("Match error")
233+    }
234+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
235+    }
236+
github/deemru/w8io/873ac7e 
23.64 ms ◑