tx · BG1NtcEhXdXnoQxcm4RkU7cmByPRnWFgRpPHjAf4yRHz

3N2V9vbP8zDTDvNMR8jQeGuUu22vz1KCv5i:  -0.01700000 Waves

2022.10.20 11:14 [2280469] smart account 3N2V9vbP8zDTDvNMR8jQeGuUu22vz1KCv5i > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BG1NtcEhXdXnoQxcm4RkU7cmByPRnWFgRpPHjAf4yRHz",
    "fee": 1700000,
    "feeAssetId": null,
    "timestamp": 1666253780378,
    "version": 1,
    "sender": "3N2V9vbP8zDTDvNMR8jQeGuUu22vz1KCv5i",
    "senderPublicKey": "3JBooHFx9f8xuJuUNn9AeF8B4U8a9onpNMbvzV3UTVTk",
    "proofs": [
        "2d2p3e5xx1mbg77LiZdyuNbUaymX1KR77H1DNZSSzQUARGqRHCjrZjqW5hBQRvZeRqDZ4Pb6fa5URsnzB3ceUbbk"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2280469,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GMLLNavJWcjseCSktGqJGo97VaWZ6KfznxzRyFiinHP2
Next: AeBWvN6ptRuom4ZnkhVC9FAWvHvprxkCm6DPJV6X9ns

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

github/deemru/w8io/169f3d6 
73.76 ms ◑