tx · Aeqkyn2MPJEmnhtmvYzqe6NG17iU6oygrwd6xPfk5C5E

3NCN1t9DS51CKN9z5XQk8JEVCoeLuWcB9Ta:  -0.01600000 Waves

2023.03.16 17:06 [2492672] smart account 3NCN1t9DS51CKN9z5XQk8JEVCoeLuWcB9Ta > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Aeqkyn2MPJEmnhtmvYzqe6NG17iU6oygrwd6xPfk5C5E",
    "fee": 1600000,
    "feeAssetId": null,
    "timestamp": 1678975610345,
    "version": 2,
    "chainId": 84,
    "sender": "3NCN1t9DS51CKN9z5XQk8JEVCoeLuWcB9Ta",
    "senderPublicKey": "51oZnGJdivhLJkVbeVYpbwM47gdGthajooUXKadNJCmv",
    "proofs": [
        "4xsVpYhA1rtJW7w7pA9jbF49wwk5UPLgjKvpwaG5Pd1mFsgNKkD1LPTquuvFsrUsXPiT2X4RyXehta9GCrRhpd9P"
    ],
    "script": "base64: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",
    "height": 2492672,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 5ex5Wd25yHX3TTstmBY4HbJ3yPYHHk942PdyhU12Dwgu
Next: Dc6tVkfcmwork6VoKeYhFCQfrRfj9GrrRwaiiuP1wk5f

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 5 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEP = "__"
5
5
 
6
6
 
func keyManagerPublicKey () = "%s__managerPublicKey"
7
7
 
8
8
 
9
9
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
10
10
 
11
11
 
12
12
 
func keyUser (address) = makeString(["%s", address], SEP)
13
13
 
14
14
 
15
15
 
func keyRevoked (address) = makeString(["%s%s", "revoked", address], SEP)
16
16
 
17
17
 
18
18
 
func keyRevokedTotal () = makeString(["%s", "revokedTotal"], SEP)
19
19
 
20
20
 
21
21
 
func keyUserVestingStart (address) = makeString(["%s%s", "vestingStart", address], SEP)
22
22
 
23
23
 
24
24
 
func keyUserVestingEnd (address) = makeString(["%s%s", "vestingEnd", address], SEP)
25
25
 
26
26
 
27
27
 
func keyUserAmountPerBlock (address) = makeString(["%s%s", "amountPerBlock", address], SEP)
28
28
 
29
29
 
30
30
 
func keyWxAssetId () = makeString(["%s", "wxAssetId"], SEP)
31
31
 
32
32
 
33
33
 
func throwErr (msg) = throw(makeString(["vesting.ride:", msg], " "))
34
34
 
35
35
 
36
36
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
37
37
 
    case s: String => 
38
38
 
        fromBase58String(s)
39
39
 
    case _: Unit => 
40
40
 
        unit
41
41
 
    case _ => 
42
42
 
        throw("Match error")
43
43
 
}
44
44
 
45
45
 
46
46
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
47
47
 
    case s: String => 
48
48
 
        fromBase58String(s)
49
49
 
    case _: Unit => 
50
50
 
        unit
51
51
 
    case _ => 
52
52
 
        throw("Match error")
53
53
 
}
54
54
 
55
55
 
56
56
 
func mustManager (i) = {
57
57
 
    let pd = throwErr("permission denied")
58
58
 
    match managerPublicKeyOrUnit() {
59
59
 
        case pk: ByteVector => 
60
60
 
            if ((i.callerPublicKey == pk))
61
61
 
                then true
62
62
 
                else pd
63
63
 
        case _: Unit => 
64
64
 
            if ((i.caller == this))
65
65
 
                then true
66
66
 
                else pd
67
67
 
        case _ => 
68
68
 
            throw("Match error")
69
69
 
    }
70
70
 
    }
71
71
 
72
72
 
73
73
 
func valueUserS (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = makeString(["%d%d%d%d%d", totalAmount, remainingAmount, "0", claimedWXAmount, lastClaimedHeight], SEP)
74
74
 
75
75
 
76
76
 
func valueUser (totalAmount,remainingAmount,claimedWXAmount,lastClaimedHeight) = valueUserS(toString(totalAmount), toString(remainingAmount), toString(claimedWXAmount), toString(lastClaimedHeight))
77
77
 
78
78
 
79
79
 
func getUserTotalAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[1])
80
80
 
81
81
 
82
82
 
func getUserRemainingAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[2])
83
83
 
84
84
 
85
85
 
func getUserClaimedAmount (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[3])
86
86
 
87
87
 
88
88
 
func getUserLastClaimedHeight (address) = parseIntValue(split(value(getString(keyUser(address))), SEP)[5])
89
89
 
90
90
 
91
91
 
func availableToClaimNow (address) = {
92
92
 
    let isRevokedUser = valueOrElse(getBoolean(keyRevoked(address)), false)
93
93
 
    if (isRevokedUser)
94
94
 
        then getUserRemainingAmount(address)
95
95
 
        else {
96
96
 
            let lastHeight = getUserLastClaimedHeight(address)
97
97
 
            if ((lastHeight >= height))
98
98
 
                then 0
99
99
 
                else {
100
100
 
                    let end = value(getInteger(keyUserVestingEnd(address)))
101
101
 
                    if ((height > end))
102
102
 
                        then getUserRemainingAmount(address)
103
103
 
                        else {
104
104
 
                            let unclaimedPeriod = (height - lastHeight)
105
105
 
                            (value(getInteger(keyUserAmountPerBlock(address))) * unclaimedPeriod)
106
106
 
                            }
107
107
 
                    }
108
108
 
            }
109
109
 
    }
110
110
 
111
111
 
112
112
 
func claimInternal (address) = {
113
113
 
    let addr = addressFromStringValue(address)
114
114
 
    let wx = fromBase58String(value(getString(keyWxAssetId())))
115
115
 
    let amount = availableToClaimNow(address)
116
116
 
    let ensureAmount = if ((amount != 0))
117
117
 
        then true
118
118
 
        else throwErr("nothing to claim")
119
119
 
    if ((ensureAmount == ensureAmount))
120
120
 
        then {
121
121
 
            let totalAmount = getUserTotalAmount(address)
122
122
 
            let remainingAmount = getUserRemainingAmount(address)
123
123
 
            let claimedWXAmount = getUserClaimedAmount(address)
124
124
 
            let isRevokedUser = valueOrElse(getBoolean(keyRevoked(address)), false)
125
125
 
            if (isRevokedUser)
126
126
 
                then [ScriptTransfer(addr, remainingAmount, wx), StringEntry(keyUser(address), valueUser(totalAmount, 0, (claimedWXAmount + remainingAmount), height))]
127
127
 
                else [ScriptTransfer(addr, amount, wx), StringEntry(keyUser(address), valueUser(totalAmount, (remainingAmount - amount), (claimedWXAmount + amount), height))]
128
128
 
            }
129
129
 
        else throw("Strict value is not equal to itself.")
130
130
 
    }
131
131
 
132
132
 
133
133
 
@Callable(i)
134
134
 
func constructor (wxAssetId) = {
135
135
 
    let check = mustManager(i)
136
136
 
    if ((check == check))
137
137
 
        then [StringEntry(keyWxAssetId(), wxAssetId)]
138
138
 
        else throw("Strict value is not equal to itself.")
139
139
 
    }
140
140
 
141
141
 
142
142
 
143
143
 
@Callable(i)
144
144
 
func withdrawRevoked () = {
145
145
 
    let amount = valueOrElse(getInteger(keyRevokedTotal()), 0)
146
146
 
    let wx = fromBase58String(value(getString(keyWxAssetId())))
147
147
 
    let checks = [mustManager(i), if ((amount > 0))
148
148
 
        then true
149
149
 
        else throwErr("revoked amount is zero, nothing to withdraw")]
150
150
 
    if ((checks == checks))
151
151
 
        then [ScriptTransfer(i.caller, amount, wx), IntegerEntry(keyRevokedTotal(), 0)]
152
152
 
        else throw("Strict value is not equal to itself.")
153
153
 
    }
154
154
 
155
155
 
156
156
 
157
157
 
@Callable(i)
158
158
 
func createDepositFor (address,blocksDuration) = {
159
159
 
    let amount = i.payments[0].amount
160
160
 
    let endHeight = (height + blocksDuration)
161
161
 
    let vestingLen = (endHeight - height)
162
162
 
    let amountPerBlock = (amount / vestingLen)
163
163
 
    let checks = [if ((endHeight > height))
164
164
 
        then true
165
165
 
        else throwErr("endHeight must be more than height"), if ((getString(keyUser(address)) == unit))
166
166
 
        then true
167
167
 
        else throwErr("deposit for user already exists"), if ((toBase58String(value(i.payments[0].assetId)) == value(getString(keyWxAssetId()))))
168
168
 
        then true
169
169
 
        else throwErr("attached payment is not WX"), if ((amountPerBlock != 0))
170
170
 
        then true
171
171
 
        else throwErr("attached amount too small or blocksDuration too large — will claimed zero per block")]
172
172
 
    if ((checks == checks))
173
173
 
        then [StringEntry(keyUser(address), valueUser(amount, amount, 0, height)), IntegerEntry(keyUserVestingStart(address), height), IntegerEntry(keyUserVestingEnd(address), endHeight), IntegerEntry(keyUserAmountPerBlock(address), amountPerBlock)]
174
174
 
        else throw("Strict value is not equal to itself.")
175
175
 
    }
176
176
 
177
177
 
178
178
 
179
179
 
@Callable(i)
180
180
 
func increaseDepositFor (address) = {
181
181
 
    let availableToClaim = availableToClaimNow(address)
182
182
 
    let forceClaim = if ((availableToClaim > 0))
183
183
 
        then claimInternal(address)
184
184
 
        else unit
185
185
 
    if ((forceClaim == forceClaim))
186
186
 
        then {
187
187
 
            let amount = i.payments[0].amount
188
188
 
            let endHeight = value(getInteger(keyUserVestingEnd(address)))
189
189
 
            let vestingLen = (endHeight - height)
190
190
 
            let amountPerBlock = value(getInteger(keyUserAmountPerBlock(address)))
191
191
 
            let incAmountPerBlock = (amount / vestingLen)
192
192
 
            let userTotalAmount = getUserTotalAmount(address)
193
193
 
            let userRemainingAmount = getUserRemainingAmount(address)
194
194
 
            let userClaimedAmount = getUserClaimedAmount(address)
195
195
 
            let userLastClaimedHeight = getUserLastClaimedHeight(address)
196
196
 
            let checks = [if ((valueOrElse(getBoolean(keyRevoked(address)), false) == false))
197
197
 
                then true
198
198
 
                else throwErr("deposit for user is revoked"), if ((getString(keyUser(address)) != unit))
199
199
 
                then true
200
200
 
                else throwErr("deposit for user doesn't exists"), if ((toBase58String(value(i.payments[0].assetId)) == value(getString(keyWxAssetId()))))
201
201
 
                then true
202
202
 
                else throwErr("attached payment is not WX"), if ((incAmountPerBlock != 0))
203
203
 
                then true
204
204
 
                else throwErr("attached amount too small — increase is zero per block")]
205
205
 
            if ((checks == checks))
206
206
 
                then [StringEntry(keyUser(address), valueUser((userTotalAmount + amount), (userRemainingAmount + amount), userClaimedAmount, userLastClaimedHeight)), IntegerEntry(keyUserAmountPerBlock(address), (amountPerBlock + incAmountPerBlock))]
207
207
 
                else throw("Strict value is not equal to itself.")
208
208
 
            }
209
209
 
        else throw("Strict value is not equal to itself.")
210
210
 
    }
211
211
 
212
212
 
213
213
 
214
214
 
@Callable(i)
215
215
 
func revokeDepositFor (address) = {
216
216
 
    let totalAmount = getUserTotalAmount(address)
217
217
 
    let remainingAmount = getUserRemainingAmount(address)
218
218
 
    let claimedWXAmount = getUserClaimedAmount(address)
219
219
 
    let lastClaimedHeight = getUserLastClaimedHeight(address)
220
220
 
    let unclaimedAmountNow = availableToClaimNow(address)
221
221
 
    let revokedTotal = valueOrElse(getInteger(keyRevokedTotal()), 0)
222
222
 
    let amountToRevoke = (remainingAmount - unclaimedAmountNow)
223
223
 
    let newRevokedTotal = (revokedTotal + amountToRevoke)
224
224
 
    let checks = [mustManager(i), if ((getString(keyUser(address)) != unit))
225
225
 
        then true
226
226
 
        else throwErr("deposit for user is not exists"), if ((newRevokedTotal > revokedTotal))
227
227
 
        then true
228
228
 
        else throwErr("newRevokedTotal can't be less or equal than revokedTotal")]
229
229
 
    if ((checks == checks))
230
230
 
        then [BooleanEntry(keyRevoked(address), true), IntegerEntry(keyRevokedTotal(), newRevokedTotal), StringEntry(keyUser(address), valueUser(totalAmount, unclaimedAmountNow, claimedWXAmount, lastClaimedHeight))]
231
231
 
        else throw("Strict value is not equal to itself.")
232
232
 
    }
233
233
 
234
234
 
235
235
 
236
236
 
@Callable(i)
237
237
 
func claim () = claimInternal(toBase58String(i.caller.bytes))
238
238
 
239
239
 
240
240
 
241
241
 
@Callable(i)
242
242
 
func claimREADONLY (address) = {
243
243
 
    let amount = availableToClaimNow(address)
244
244
 
    $Tuple2(nil, amount)
245
245
 
    }
246
246
 
247
247
 
248
248
 
249
249
 
@Callable(i)
250
250
 
func stats (address) = $Tuple2(nil, [value(getInteger(keyUserVestingStart(address))), value(getInteger(keyUserVestingEnd(address))), getUserTotalAmount(address), getUserClaimedAmount(address), getUserRemainingAmount(address), availableToClaimNow(address)])
251
251
 
252
252
 
253
253
 
254
254
 
@Callable(i)
255
255
 
func setManager (pendingManagerPublicKey) = {
256
256
 
    let checkCaller = mustManager(i)
257
257
 
    if ((checkCaller == checkCaller))
258
258
 
        then {
259
259
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
260
260
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
261
261
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
262
262
 
                else throw("Strict value is not equal to itself.")
263
263
 
            }
264
264
 
        else throw("Strict value is not equal to itself.")
265
265
 
    }
266
266
 
267
267
 
268
268
 
269
269
 
@Callable(i)
270
270
 
func confirmManager () = {
271
271
 
    let pm = pendingManagerPublicKeyOrUnit()
272
272
 
    let hasPM = if (isDefined(pm))
273
273
 
        then true
274
274
 
        else throwErr("no pending manager")
275
275
 
    if ((hasPM == hasPM))
276
276
 
        then {
277
277
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
278
278
 
                then true
279
279
 
                else throwErr("you are not pending manager")
280
280
 
            if ((checkPM == checkPM))
281
281
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
282
282
 
                else throw("Strict value is not equal to itself.")
283
283
 
            }
284
284
 
        else throw("Strict value is not equal to itself.")
285
285
 
    }
286
286
 
287
287
 
288
288
 
@Verifier(tx)
289
289
 
func verify () = {
290
290
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
291
291
 
        case pk: ByteVector => 
292
292
 
            pk
293
293
 
        case _: Unit => 
294
294
 
            tx.senderPublicKey
295
295
 
        case _ => 
296
296
 
            throw("Match error")
297
297
 
    }
298
298
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
299
299
 
    }
300
300
 

github/deemru/w8io/873ac7e 
51.70 ms ◑