tx · 2N7vhN6jBWpR38ucttgJjCUxjp2TsfVz17HD1iPN8nCr

3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz:  -0.01400000 Waves

2022.05.05 17:02 [2038490] smart account 3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2N7vhN6jBWpR38ucttgJjCUxjp2TsfVz17HD1iPN8nCr",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1651759403724,
    "version": 1,
    "sender": "3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz",
    "senderPublicKey": "E7cYpzqL1fF9VQjL3m4zr3xXfV289rCkrfE2fJyAHMqR",
    "proofs": [
        "283SipgaEvSgFwmgdMNymsVC9xhtwxjqG8unE5nYtrWuerv7cufufbQzaq2euq1JgeFECzSGom4k86d6VDkDc4C7"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2038490,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GFJuSYFo2r5W5gyztUWenFpxTcD4BxxQAtvAGoQ1CoW8
Next: 6iMHavscDYT1uv5PncfW99MvxNABQqhdJrK4XiQGg6T4

Diff: 

OldNewDifferences
8686 
8787 
8888 func availableToClaimNow (address) = {
89-    let lastHeight = getUserLastClaimedHeight(address)
90-    if ((lastHeight >= height))
91-        then 0
89+    let isRevokedUser = valueOrElse(getBoolean(keyRevoked(address)), false)
90+    if (isRevokedUser)
91+        then getUserRemainingAmount(address)
9292         else {
93-            let end = value(getInteger(keyUserVestingEnd(address)))
94-            if ((height > end))
95-                then getUserRemainingAmount(address)
93+            let lastHeight = getUserLastClaimedHeight(address)
94+            if ((lastHeight >= height))
95+                then 0
9696                 else {
97-                    let unclaimedPeriod = (height - lastHeight)
98-                    (value(getInteger(keyUserAmountPerBlock(address))) * unclaimedPeriod)
97+                    let end = value(getInteger(keyUserVestingEnd(address)))
98+                    if ((height > end))
99+                        then getUserRemainingAmount(address)
100+                        else {
101+                            let unclaimedPeriod = (height - lastHeight)
102+                            (value(getInteger(keyUserAmountPerBlock(address))) * unclaimedPeriod)
103+                            }
99104                     }
100105             }
101106     }
114119 @Callable(i)
115120 func createDepositFor (address,blocksDuration) = {
116121     let endHeight = (height + blocksDuration)
122+    let amount = i.payments[0].amount
123+    let vestingLen = (endHeight - height)
124+    let amountPerBlock = (amount / vestingLen)
117125     let checks = [mustManager(i), if ((endHeight > height))
118126         then true
119127         else throwErr("endHeight must be more than height"), if ((getString(keyUser(address)) == unit))
120128         then true
121129         else throwErr("deposit for user already exists"), if ((toBase58String(value(i.payments[0].assetId)) == value(getString(keyWxAssetId()))))
122130         then true
123-        else throwErr("attached payment is not WX")]
131+        else throwErr("attached payment is not WX"), if ((amountPerBlock != 0))
132+        then true
133+        else throwErr("attached amount too small or blocksDuration too large — will claimed zero per block")]
124134     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-            }
135+        then [StringEntry(keyUser(address), valueUser(amount, amount, 0, height)), IntegerEntry(keyUserVestingStart(address), height), IntegerEntry(keyUserVestingEnd(address), endHeight), IntegerEntry(keyUserAmountPerBlock(address), amountPerBlock)]
130136         else throw("Strict value is not equal to itself.")
131137     }
132138 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 func keyManagerPublicKey () = "%s__managerPublicKey"
77 
88 
99 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
1010 
1111 
1212 func keyUser (address) = makeString(["%s", address], SEP)
1313 
1414 
1515 func keyRevoked (address) = makeString(["%s", "revoked", address], SEP)
1616 
1717 
1818 func keyUserVestingStart (address) = makeString(["%s", "vestingStart", address], SEP)
1919 
2020 
2121 func keyUserVestingEnd (address) = makeString(["%s", "vestingEnd", address], SEP)
2222 
2323 
2424 func keyUserAmountPerBlock (address) = makeString(["%s", "amountPerBlock", address], SEP)
2525 
2626 
2727 func keyWxAssetId () = makeString(["%s", "wxAssetId"], SEP)
2828 
2929 
3030 func throwErr (msg) = throw(makeString(["vesting.ride:", msg], " "))
3131 
3232 
3333 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
3434     case s: String => 
3535         fromBase58String(s)
3636     case _: Unit => 
3737         unit
3838     case _ => 
3939         throw("Match error")
4040 }
4141 
4242 
4343 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
4444     case s: String => 
4545         fromBase58String(s)
4646     case _: Unit => 
4747         unit
4848     case _ => 
4949         throw("Match error")
5050 }
5151 
5252 
5353 func mustManager (i) = {
5454     let pd = throwErr("permission denied")
5555     match managerPublicKeyOrUnit() {
5656         case pk: ByteVector => 
5757             if ((i.callerPublicKey == pk))
5858                 then true
5959                 else pd
6060         case _: Unit => 
6161             if ((i.caller == this))
6262                 then true
6363                 else pd
6464         case _ => 
6565             throw("Match error")
6666     }
6767     }
6868 
6969 
7070 func valueUserS (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = makeString(["%d%d%d%d%d", totalAmount, remainingAmount, "0", claimedWXAmount, lastClaimedHeight], SEP)
7171 
7272 
7373 func valueUser (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = valueUserS(toString(totalAmount), toString(remainingAmount), toString(claimedWXAmount), toString(lastClaimedHeight))
7474 
7575 
7676 func getUserTotalAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[1])
7777 
7878 
7979 func getUserRemainingAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[2])
8080 
8181 
8282 func getUserClaimedAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[3])
8383 
8484 
8585 func getUserLastClaimedHeight (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[5])
8686 
8787 
8888 func availableToClaimNow (address) = {
89-    let lastHeight = getUserLastClaimedHeight(address)
90-    if ((lastHeight >= height))
91-        then 0
89+    let isRevokedUser = valueOrElse(getBoolean(keyRevoked(address)), false)
90+    if (isRevokedUser)
91+        then getUserRemainingAmount(address)
9292         else {
93-            let end = value(getInteger(keyUserVestingEnd(address)))
94-            if ((height > end))
95-                then getUserRemainingAmount(address)
93+            let lastHeight = getUserLastClaimedHeight(address)
94+            if ((lastHeight >= height))
95+                then 0
9696                 else {
97-                    let unclaimedPeriod = (height - lastHeight)
98-                    (value(getInteger(keyUserAmountPerBlock(address))) * unclaimedPeriod)
97+                    let end = value(getInteger(keyUserVestingEnd(address)))
98+                    if ((height > end))
99+                        then getUserRemainingAmount(address)
100+                        else {
101+                            let unclaimedPeriod = (height - lastHeight)
102+                            (value(getInteger(keyUserAmountPerBlock(address))) * unclaimedPeriod)
103+                            }
99104                     }
100105             }
101106     }
102107 
103108 
104109 @Callable(i)
105110 func constructor (wxAssetId) = {
106111     let check = mustManager(i)
107112     if ((check == check))
108113         then [StringEntry(keyWxAssetId(), wxAssetId)]
109114         else throw("Strict value is not equal to itself.")
110115     }
111116 
112117 
113118 
114119 @Callable(i)
115120 func createDepositFor (address,blocksDuration) = {
116121     let endHeight = (height + blocksDuration)
122+    let amount = i.payments[0].amount
123+    let vestingLen = (endHeight - height)
124+    let amountPerBlock = (amount / vestingLen)
117125     let checks = [mustManager(i), if ((endHeight > height))
118126         then true
119127         else throwErr("endHeight must be more than height"), if ((getString(keyUser(address)) == unit))
120128         then true
121129         else throwErr("deposit for user already exists"), if ((toBase58String(value(i.payments[0].assetId)) == value(getString(keyWxAssetId()))))
122130         then true
123-        else throwErr("attached payment is not WX")]
131+        else throwErr("attached payment is not WX"), if ((amountPerBlock != 0))
132+        then true
133+        else throwErr("attached amount too small or blocksDuration too large — will claimed zero per block")]
124134     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-            }
135+        then [StringEntry(keyUser(address), valueUser(amount, amount, 0, height)), IntegerEntry(keyUserVestingStart(address), height), IntegerEntry(keyUserVestingEnd(address), endHeight), IntegerEntry(keyUserAmountPerBlock(address), amountPerBlock)]
130136         else throw("Strict value is not equal to itself.")
131137     }
132138 
133139 
134140 
135141 @Callable(i)
136142 func revokeDepositFor (address) = {
137143     let checks = [mustManager(i), if ((getString(keyUser(address)) != unit))
138144         then true
139145         else throwErr("deposit for user is not exists")]
140146     if ((checks == checks))
141147         then {
142148             let totalAmount = getUserTotalAmount(address)
143149             let amount = availableToClaimNow(address)
144150             let claimedWXAmount = getUserClaimedAmount(address)
145151             let lastClaimedHeight = getUserLastClaimedHeight(address)
146152 [BooleanEntry(keyRevoked(address), true), StringEntry(keyUser(address), valueUser(totalAmount, amount, claimedWXAmount, lastClaimedHeight))]
147153             }
148154         else throw("Strict value is not equal to itself.")
149155     }
150156 
151157 
152158 
153159 @Callable(i)
154160 func claim () = {
155161     let addr = i.caller
156162     let addrStr = toString(addr)
157163     let wx = fromBase58String(value(getString(keyWxAssetId())))
158164     let amount = availableToClaimNow(addrStr)
159165     let ensureAmount = if ((amount != 0))
160166         then true
161167         else throwErr("nothing to claim")
162168     if ((ensureAmount == ensureAmount))
163169         then {
164170             let totalAmount = getUserTotalAmount(addrStr)
165171             let remainingAmount = getUserRemainingAmount(addrStr)
166172             let claimedWXAmount = getUserClaimedAmount(addrStr)
167173             let isRevokedUser = valueOrElse(getBoolean(keyRevoked(addrStr)), false)
168174             if (isRevokedUser)
169175                 then [ScriptTransfer(addr, remainingAmount, wx), StringEntry(keyUser(addrStr), valueUser(totalAmount, 0, (claimedWXAmount + remainingAmount), height))]
170176                 else [ScriptTransfer(addr, amount, wx), StringEntry(keyUser(addrStr), valueUser(totalAmount, (remainingAmount - amount), (claimedWXAmount + amount), height))]
171177             }
172178         else throw("Strict value is not equal to itself.")
173179     }
174180 
175181 
176182 
177183 @Callable(i)
178184 func claimREADONLY (address) = {
179185     let amount = availableToClaimNow(address)
180186     $Tuple2(nil, amount)
181187     }
182188 
183189 
184190 
185191 @Callable(i)
186192 func stats (address) = $Tuple2(nil, [value(getInteger(keyUserVestingStart(address))), value(getInteger(keyUserVestingEnd(address))), getUserTotalAmount(address), getUserClaimedAmount(address), getUserRemainingAmount(address), availableToClaimNow(address)])
187193 
188194 
189195 
190196 @Callable(i)
191197 func setManager (pendingManagerPublicKey) = {
192198     let checkCaller = mustManager(i)
193199     if ((checkCaller == checkCaller))
194200         then {
195201             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
196202             if ((checkManagerPublicKey == checkManagerPublicKey))
197203                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
198204                 else throw("Strict value is not equal to itself.")
199205             }
200206         else throw("Strict value is not equal to itself.")
201207     }
202208 
203209 
204210 
205211 @Callable(i)
206212 func confirmManager () = {
207213     let pm = pendingManagerPublicKeyOrUnit()
208214     let hasPM = if (isDefined(pm))
209215         then true
210216         else throwErr("no pending manager")
211217     if ((hasPM == hasPM))
212218         then {
213219             let checkPM = if ((i.callerPublicKey == value(pm)))
214220                 then true
215221                 else throwErr("you are not pending manager")
216222             if ((checkPM == checkPM))
217223                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
218224                 else throw("Strict value is not equal to itself.")
219225             }
220226         else throw("Strict value is not equal to itself.")
221227     }
222228 
223229 
224230 @Verifier(tx)
225231 func verify () = {
226232     let targetPublicKey =     match managerPublicKeyOrUnit() {
227233         case pk: ByteVector => 
228234             pk
229235         case _: Unit => 
230236             tx.senderPublicKey
231237         case _ => 
232238             throw("Match error")
233239     }
234240     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
235241     }
236242 
github/deemru/w8io/c3f4982 
43.51 ms ◑