tx · Dx2SV1JCHKuP6j3NR7k47VFDPgwhjfnBcRzQqN97W38S

3N2V9vbP8zDTDvNMR8jQeGuUu22vz1KCv5i:  -0.02200000 Waves

2022.09.12 12:58 [2225732] smart account 3N2V9vbP8zDTDvNMR8jQeGuUu22vz1KCv5i > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Dx2SV1JCHKuP6j3NR7k47VFDPgwhjfnBcRzQqN97W38S",
    "fee": 2200000,
    "feeAssetId": null,
    "timestamp": 1662976715981,
    "version": 1,
    "sender": "3N2V9vbP8zDTDvNMR8jQeGuUu22vz1KCv5i",
    "senderPublicKey": "3JBooHFx9f8xuJuUNn9AeF8B4U8a9onpNMbvzV3UTVTk",
    "proofs": [
        "37U6ZEWLHMTYuVbNL9rypKdhETZ4pGqoP29h83kwFCoXbk8sY9bkXehzTMt8oHxvmwAPZqHEQJTVDF16jC6qckq"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2225732,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: ELq4XBjtrY6WfpJaZMFx8d5h5LwUUzWBroq93zEYFuYy
Next: GMLLNavJWcjseCSktGqJGo97VaWZ6KfznxzRyFiinHP2

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

github/deemru/w8io/169f3d6 
54.78 ms ◑