tx · 8npgMzg1irXfC3FTU2am5pqaSD5y4YTeGWNVFEpDB6CS

3N7GMYZFabKLRK9cuquU5WbqCwDS6XCaoos:  -0.02200000 Waves

2023.02.21 15:50 [2459434] smart account 3N7GMYZFabKLRK9cuquU5WbqCwDS6XCaoos > SELF 0.00000000 Waves

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

View: original | compacted
Prev: cs9ENzg87f75r8VbNrpgoztw8ofeXR6yiNkmv6BZ2Jb
Next: 4P1iFa1hbbPKETzCgey3Z3QvbGdmDtKJD8FSameg7UHb

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/026f985 
57.19 ms ◑