tx · GH7A7vgC3Wc6qjGv48vQS2WrnvyQ2V6Qw7nx4PaCjGdV

3N7GMYZFabKLRK9cuquU5WbqCwDS6XCaoos:  -0.02200000 Waves

2023.02.21 11:30 [2459170] smart account 3N7GMYZFabKLRK9cuquU5WbqCwDS6XCaoos > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GH7A7vgC3Wc6qjGv48vQS2WrnvyQ2V6Qw7nx4PaCjGdV",
    "fee": 2200000,
    "feeAssetId": null,
    "timestamp": 1676968215186,
    "version": 1,
    "sender": "3N7GMYZFabKLRK9cuquU5WbqCwDS6XCaoos",
    "senderPublicKey": "6BdD8SRuqTo5GU1fTwkJmKFRybVGvTmacZrozz9NoHbw",
    "proofs": [
        "3B1Hczxz2ato62uy8Pe2StF1eP1rDrCirwpjzNJUaF69fbTRS8RGJo7ant9YBATzXv7bfRVB6cvqw4gGm3HFWFhT"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2459170,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: cs9ENzg87f75r8VbNrpgoztw8ofeXR6yiNkmv6BZ2Jb

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let EMPTY = ""
7+
8+func keyManagerPublicKey () = "%s__managerPublicKey"
9+
10+
11+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
12+
13+
14+func keyAdminPubKeys () = "%s__adminPubKeys"
15+
16+
17+func keyUser (assetId,address) = makeString(["%s%s", assetId, address], SEP)
18+
19+
20+func keyUserFixedDeposit (assetId,address,block) = makeString(["%s%s%s%d", "fixedDeposit", assetId, address, toString(block)], SEP)
21+
22+
23+func keyRevoked (assetId,address) = makeString(["%s%s%s", "revoked", assetId, address], SEP)
24+
25+
26+func keyRevokedTotal (assetId) = makeString(["%s%s", "revokedTotal", assetId], SEP)
27+
28+
29+func keyUserVestingStart (assetId,address) = makeString(["%s%s%s", "vestingStart", assetId, address], SEP)
30+
31+
32+func keyUserVestingEnd (assetId,address) = makeString(["%s%s%s", "vestingEnd", assetId, address], SEP)
33+
34+
35+func keyUserAmountPerBlock (assetId,address) = makeString(["%s%s%s", "amountPerBlock", assetId, address], SEP)
36+
37+
38+func keyClaimDenied (assetId) = makeString(["%s%s", "claimDenied", assetId], SEP)
39+
40+
41+func throwErr (msg) = throw(makeString(["vesting_multiasset.ride:", msg], " "))
42+
43+
44+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
45+    case s: String => 
46+        fromBase58String(s)
47+    case _: Unit => 
48+        unit
49+    case _ => 
50+        throw("Match error")
51+}
52+
53+
54+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
55+    case s: String => 
56+        fromBase58String(s)
57+    case _: Unit => 
58+        unit
59+    case _ => 
60+        throw("Match error")
61+}
62+
63+
64+func mustManager (i) = {
65+    let pd = throwErr("permission denied")
66+    match managerPublicKeyOrUnit() {
67+        case pk: ByteVector => 
68+            if ((i.callerPublicKey == pk))
69+                then true
70+                else pd
71+        case _: Unit => 
72+            if ((i.caller == this))
73+                then true
74+                else pd
75+        case _ => 
76+            throw("Match error")
77+    }
78+    }
79+
80+
81+func mustAdmin (i) = {
82+    let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
83+    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
84+        then true
85+        else {
86+            let isManager = mustManager(i)
87+            if ((isManager == isManager))
88+                then true
89+                else throw("Strict value is not equal to itself.")
90+            }
91+    }
92+
93+
94+func valueUserS (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = makeString(["%d%d%d%d%d", totalAmount, remainingAmount, "0", claimedWXAmount, lastClaimedHeight], SEP)
95+
96+
97+func valueUser (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = valueUserS(toString(totalAmount), toString(remainingAmount), toString(claimedWXAmount), toString(lastClaimedHeight))
98+
99+
100+func getUserTotalAmount (assetId,address) = parseIntValue(split(value(getString(keyUser(assetId, address))), SEP)[1])
101+
102+
103+func getUserRemainingAmount (assetId,address) = parseIntValue(split(value(getString(keyUser(assetId, address))), SEP)[2])
104+
105+
106+func getUserClaimedAmount (assetId,address) = parseIntValue(split(value(getString(keyUser(assetId, address))), SEP)[3])
107+
108+
109+func getUserLastClaimedHeight (assetId,address) = parseIntValue(split(value(getString(keyUser(assetId, address))), SEP)[5])
110+
111+
112+func availableToClaimNow (assetId,address) = {
113+    let isRevokedUser = valueOrElse(getBoolean(keyRevoked(assetId, address)), false)
114+    if (isRevokedUser)
115+        then getUserRemainingAmount(assetId, address)
116+        else {
117+            let lastHeight = getUserLastClaimedHeight(assetId, address)
118+            if ((lastHeight >= height))
119+                then 0
120+                else {
121+                    let end = value(getInteger(keyUserVestingEnd(assetId, address)))
122+                    if ((height > end))
123+                        then getUserRemainingAmount(assetId, address)
124+                        else {
125+                            let unclaimedPeriod = (height - lastHeight)
126+                            (value(getInteger(keyUserAmountPerBlock(assetId, address))) * unclaimedPeriod)
127+                            }
128+                    }
129+            }
130+    }
131+
132+
133+func availableToClaimFixed (assetId,address,releaseBlock) = valueOrElse(getInteger(keyUserFixedDeposit(assetId, address, releaseBlock)), 0)
134+
135+
136+func claimInternal (assetId,address) = {
137+    let addr = addressFromStringValue(address)
138+    let asset = fromBase58String(assetId)
139+    let amount = availableToClaimNow(assetId, address)
140+    let checks = [if ((valueOrElse(getBoolean(keyClaimDenied(assetId)), false) == false))
141+        then true
142+        else throwErr("asset claim denied"), if ((amount != 0))
143+        then true
144+        else throwErr("nothing to claim")]
145+    if ((checks == checks))
146+        then {
147+            let totalAmount = getUserTotalAmount(assetId, address)
148+            let remainingAmount = getUserRemainingAmount(assetId, address)
149+            let claimedAmount = getUserClaimedAmount(assetId, address)
150+            let isRevokedUser = valueOrElse(getBoolean(keyRevoked(assetId, address)), false)
151+            if (isRevokedUser)
152+                then [ScriptTransfer(addr, remainingAmount, asset), StringEntry(keyUser(assetId, address), valueUser(totalAmount, 0, (claimedAmount + remainingAmount), height))]
153+                else [ScriptTransfer(addr, amount, asset), StringEntry(keyUser(assetId, address), valueUser(totalAmount, (remainingAmount - amount), (claimedAmount + amount), height))]
154+            }
155+        else throw("Strict value is not equal to itself.")
156+    }
157+
158+
159+func claimFixedInternal (assetId,address,releaseBlock) = {
160+    let userFixedDeposit = getInteger(keyUserFixedDeposit(assetId, address, releaseBlock))
161+    let checks = [if ((valueOrElse(getBoolean(keyClaimDenied(assetId)), false) == false))
162+        then true
163+        else throwErr("asset claim denied"), if ((height > releaseBlock))
164+        then true
165+        else throwErr("current height must be more than releaseBlock for fixed deposit"), if ((valueOrElse(userFixedDeposit, 0) != 0))
166+        then true
167+        else throwErr("no fixed deposit for assetId/address/height")]
168+    if ((checks == checks))
169+        then {
170+            let addr = addressFromStringValue(address)
171+            let asset = fromBase58String(assetId)
172+            let amount = value(userFixedDeposit)
173+[ScriptTransfer(addr, amount, asset), IntegerEntry(keyUserFixedDeposit(assetId, address, releaseBlock), 0)]
174+            }
175+        else throw("Strict value is not equal to itself.")
176+    }
177+
178+
179+@Callable(i)
180+func withdrawRevoked (assetId) = {
181+    let amount = valueOrElse(getInteger(keyRevokedTotal(assetId)), 0)
182+    let asset = fromBase58String(assetId)
183+    let checks = [mustManager(i), if ((amount > 0))
184+        then true
185+        else throwErr("revoked amount is zero, nothing to withdraw")]
186+    if ((checks == checks))
187+        then [ScriptTransfer(i.caller, amount, asset), IntegerEntry(keyRevokedTotal(assetId), 0)]
188+        else throw("Strict value is not equal to itself.")
189+    }
190+
191+
192+
193+@Callable(i)
194+func createDepositFor (address,blocksDuration) = {
195+    let amount = i.payments[0].amount
196+    let assetId = toBase58String(value(i.payments[0].assetId))
197+    let endHeight = (height + blocksDuration)
198+    let vestingLen = (endHeight - height)
199+    let amountPerBlock = (amount / vestingLen)
200+    let checks = [if ((endHeight > height))
201+        then true
202+        else throwErr("endHeight must be more than height"), if ((getString(keyUser(assetId, address)) == unit))
203+        then true
204+        else throwErr("deposit of this asset for user already exists"), if ((amountPerBlock != 0))
205+        then true
206+        else throwErr("attached amount too small or blocksDuration too large — will claimed zero per block")]
207+    if ((checks == checks))
208+        then [StringEntry(keyUser(assetId, address), valueUser(amount, amount, 0, height)), IntegerEntry(keyUserVestingStart(assetId, address), height), IntegerEntry(keyUserVestingEnd(assetId, address), endHeight), IntegerEntry(keyUserAmountPerBlock(assetId, address), amountPerBlock)]
209+        else throw("Strict value is not equal to itself.")
210+    }
211+
212+
213+
214+@Callable(i)
215+func increaseDepositFor (address) = {
216+    let amount = i.payments[0].amount
217+    let assetId = toBase58String(value(i.payments[0].assetId))
218+    let availableToClaim = availableToClaimNow(assetId, address)
219+    let forceClaim = if ((availableToClaim > 0))
220+        then claimInternal(assetId, address)
221+        else unit
222+    if ((forceClaim == forceClaim))
223+        then {
224+            let endHeight = value(getInteger(keyUserVestingEnd(assetId, address)))
225+            let vestingLen = (endHeight - height)
226+            let amountPerBlock = value(getInteger(keyUserAmountPerBlock(assetId, address)))
227+            let incAmountPerBlock = (amount / vestingLen)
228+            let userTotalAmount = getUserTotalAmount(assetId, address)
229+            let userRemainingAmount = getUserRemainingAmount(assetId, address)
230+            let userClaimedAmount = getUserClaimedAmount(assetId, address)
231+            let userLastClaimedHeight = getUserLastClaimedHeight(assetId, address)
232+            let checks = [if ((valueOrElse(getBoolean(keyRevoked(assetId, address)), false) == false))
233+                then true
234+                else throwErr("deposit for user is revoked"), if ((getString(keyUser(assetId, address)) != unit))
235+                then true
236+                else throwErr("deposit for user doesn't exists"), if ((incAmountPerBlock != 0))
237+                then true
238+                else throwErr("attached amount too small — increase is zero per block")]
239+            if ((checks == checks))
240+                then [StringEntry(keyUser(assetId, address), valueUser((userTotalAmount + amount), (userRemainingAmount + amount), userClaimedAmount, userLastClaimedHeight)), IntegerEntry(keyUserAmountPerBlock(assetId, address), (amountPerBlock + incAmountPerBlock))]
241+                else throw("Strict value is not equal to itself.")
242+            }
243+        else throw("Strict value is not equal to itself.")
244+    }
245+
246+
247+
248+@Callable(i)
249+func revokeDepositFor (assetId,address) = {
250+    let totalAmount = getUserTotalAmount(assetId, address)
251+    let remainingAmount = getUserRemainingAmount(assetId, address)
252+    let claimedWXAmount = getUserClaimedAmount(assetId, address)
253+    let lastClaimedHeight = getUserLastClaimedHeight(assetId, address)
254+    let unclaimedAmountNow = availableToClaimNow(assetId, address)
255+    let revokedTotal = valueOrElse(getInteger(keyRevokedTotal(assetId)), 0)
256+    let amountToRevoke = (remainingAmount - unclaimedAmountNow)
257+    let newRevokedTotal = (revokedTotal + amountToRevoke)
258+    let checks = [mustAdmin(i), if ((getString(keyUser(assetId, address)) != unit))
259+        then true
260+        else throwErr("deposit of this asset for user is not exists"), if ((newRevokedTotal > revokedTotal))
261+        then true
262+        else throwErr("newRevokedTotal can't be less or equal than revokedTotal")]
263+    if ((checks == checks))
264+        then [BooleanEntry(keyRevoked(assetId, address), true), IntegerEntry(keyRevokedTotal(assetId), newRevokedTotal), StringEntry(keyUser(assetId, address), valueUser(totalAmount, unclaimedAmountNow, claimedWXAmount, lastClaimedHeight))]
265+        else throw("Strict value is not equal to itself.")
266+    }
267+
268+
269+
270+@Callable(i)
271+func claim (assetId) = claimInternal(assetId, toBase58String(i.caller.bytes))
272+
273+
274+
275+@Callable(i)
276+func claimFor (assetId,address) = claimInternal(assetId, address)
277+
278+
279+
280+@Callable(i)
281+func claimREADONLY (assetId,address) = {
282+    let amount = availableToClaimNow(assetId, address)
283+    $Tuple2(nil, amount)
284+    }
285+
286+
287+
288+@Callable(i)
289+func createFixedDepositFor (address,releaseBlock) = {
290+    let amount = i.payments[0].amount
291+    let assetId = toBase58String(value(i.payments[0].assetId))
292+    let userFixedDeposit = keyUserFixedDeposit(assetId, address, releaseBlock)
293+    let checks = [if ((releaseBlock > height))
294+        then true
295+        else throwErr("releaseBlock must be more than height"), if ((getInteger(userFixedDeposit) == unit))
296+        then true
297+        else throwErr("deposit for this height for user already exists")]
298+    if ((checks == checks))
299+        then [IntegerEntry(userFixedDeposit, amount)]
300+        else throw("Strict value is not equal to itself.")
301+    }
302+
303+
304+
305+@Callable(i)
306+func claimFixed (assetId,releaseBlock) = claimFixedInternal(assetId, toBase58String(i.caller.bytes), releaseBlock)
307+
308+
309+
310+@Callable(i)
311+func claimFixedFor (assetId,address,releaseBlock) = claimFixedInternal(assetId, address, releaseBlock)
312+
313+
314+
315+@Callable(i)
316+func claimFixedREADONLY (assetId,address,releaseBlock) = {
317+    let amount = availableToClaimFixed(assetId, address, releaseBlock)
318+    $Tuple2(nil, amount)
319+    }
320+
321+
322+
323+@Callable(i)
324+func revokeFixedDepositFor (assetId,address,releaseBlock) = {
325+    let checks = [mustAdmin(i), if ((releaseBlock > height))
326+        then true
327+        else throwErr("can't revoke deposit in past"), if ((valueOrElse(getInteger(keyUserFixedDeposit(assetId, address, releaseBlock)), 0) != 0))
328+        then true
329+        else throwErr("deposit for this height for user not exists")]
330+    if ((checks == checks))
331+        then {
332+            let amount = value(getInteger(keyUserFixedDeposit(assetId, address, releaseBlock)))
333+[IntegerEntry(keyRevokedTotal(assetId), amount), IntegerEntry(keyUserFixedDeposit(assetId, address, releaseBlock), 0)]
334+            }
335+        else throw("Strict value is not equal to itself.")
336+    }
337+
338+
339+
340+@Callable(i)
341+func denyAssetClaim (assetId) = {
342+    let checks = [mustAdmin(i), if ((valueOrElse(getBoolean(keyClaimDenied(assetId)), false) == false))
343+        then true
344+        else throwErr("asset already denied")]
345+    if ((checks == checks))
346+        then [BooleanEntry(keyClaimDenied(assetId), true)]
347+        else throw("Strict value is not equal to itself.")
348+    }
349+
350+
351+
352+@Callable(i)
353+func allowAssetClaim (assetId) = {
354+    let checks = [mustAdmin(i), if ((valueOrElse(getBoolean(keyClaimDenied(assetId)), false) == true))
355+        then true
356+        else throwErr("asset already allowed")]
357+    if ((checks == checks))
358+        then [DeleteEntry(keyClaimDenied(assetId))]
359+        else throw("Strict value is not equal to itself.")
360+    }
361+
362+
363+
364+@Callable(i)
365+func stats (assetId,address) = $Tuple2(nil, [value(getInteger(keyUserVestingStart(assetId, address))), value(getInteger(keyUserVestingEnd(assetId, address))), getUserTotalAmount(assetId, address), getUserClaimedAmount(assetId, address), getUserRemainingAmount(assetId, address), availableToClaimNow(assetId, address)])
366+
367+
368+
369+@Callable(i)
370+func setManager (pendingManagerPublicKey) = {
371+    let checkCaller = mustManager(i)
372+    if ((checkCaller == checkCaller))
373+        then {
374+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
375+            if ((checkManagerPublicKey == checkManagerPublicKey))
376+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
377+                else throw("Strict value is not equal to itself.")
378+            }
379+        else throw("Strict value is not equal to itself.")
380+    }
381+
382+
383+
384+@Callable(i)
385+func confirmManager () = {
386+    let pm = pendingManagerPublicKeyOrUnit()
387+    let hasPM = if (isDefined(pm))
388+        then true
389+        else throwErr("no pending manager")
390+    if ((hasPM == hasPM))
391+        then {
392+            let checkPM = if ((i.callerPublicKey == value(pm)))
393+                then true
394+                else throwErr("you are not pending manager")
395+            if ((checkPM == checkPM))
396+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
397+                else throw("Strict value is not equal to itself.")
398+            }
399+        else throw("Strict value is not equal to itself.")
400+    }
401+
402+
403+@Verifier(tx)
404+func verify () = {
405+    let targetPublicKey =     match managerPublicKeyOrUnit() {
406+        case pk: ByteVector => 
407+            pk
408+        case _: Unit => 
409+            tx.senderPublicKey
410+        case _ => 
411+            throw("Match error")
412+    }
413+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
414+    }
415+
github/deemru/w8io/026f985 
47.91 ms ◑