tx · 6iMHavscDYT1uv5PncfW99MvxNABQqhdJrK4XiQGg6T4

3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz:  -0.01400000 Waves

2022.05.10 15:30 [2045570] smart account 3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6iMHavscDYT1uv5PncfW99MvxNABQqhdJrK4XiQGg6T4",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1652185843124,
    "version": 1,
    "sender": "3MqV2hxYA4F3eyVzMPfpPXkmvQMVjhWJ2Zz",
    "senderPublicKey": "E7cYpzqL1fF9VQjL3m4zr3xXfV289rCkrfE2fJyAHMqR",
    "proofs": [
        "67KKA6uLumjgkiwBU7HD1a5cSRT7qyL9c5Z3WtRo2VGkFx6RFdxnoprXwDLBDM1XR3EDTHYeadMY9MGgjoHxKMBp"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2045570,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2N7vhN6jBWpR38ucttgJjCUxjp2TsfVz17HD1iPN8nCr
Next: 9yS2XqdA2CSaP83fdiEnXmLdKDuMuwtToZQYyBcSvyHr

Diff: 
Old
New
Differences
12
12
 
func keyUser (address) = makeString(["%s", address], SEP)
13
13
 
14
14
 
15
-
func keyRevoked (address) = makeString(["%s", "revoked", address], SEP)
15
+
func keyRevoked (address) = makeString(["%s%s", "revoked", address], SEP)
16
16
 
17
17
 
18
-
func keyUserVestingStart (address) = makeString(["%s", "vestingStart", address], SEP)
18
+
func keyRevokedTotal () = makeString(["%s", "revokedTotal"], SEP)
19
19
 
20
20
 
21
-
func keyUserVestingEnd (address) = makeString(["%s", "vestingEnd", address], SEP)
21
+
func keyUserVestingStart (address) = makeString(["%s%s", "vestingStart", address], SEP)
22
22
 
23
23
 
24
-
func keyUserAmountPerBlock (address) = makeString(["%s", "amountPerBlock", address], SEP)
24
+
func keyUserVestingEnd (address) = makeString(["%s%s", "vestingEnd", address], SEP)
25
+
26
+
27
+
func keyUserAmountPerBlock (address) = makeString(["%s%s", "amountPerBlock", address], SEP)
25
28
 
26
29
 
27
30
 
func keyWxAssetId () = makeString(["%s", "wxAssetId"], SEP)
106
109
 
    }
107
110
 
108
111
 
112
+
func claimInternal (address) = {
113
+
    let addr = Address(value(fromBase58String(address)))
114
+
    let wx = fromBase58String(value(getString(keyWxAssetId())))
115
+
    let amount = availableToClaimNow(address)
116
+
    let ensureAmount = if ((amount != 0))
117
+
        then true
118
+
        else throwErr("nothing to claim")
119
+
    if ((ensureAmount == ensureAmount))
120
+
        then {
121
+
            let totalAmount = getUserTotalAmount(address)
122
+
            let remainingAmount = getUserRemainingAmount(address)
123
+
            let claimedWXAmount = getUserClaimedAmount(address)
124
+
            let isRevokedUser = valueOrElse(getBoolean(keyRevoked(address)), false)
125
+
            if (isRevokedUser)
126
+
                then [ScriptTransfer(addr, remainingAmount, wx), StringEntry(keyUser(address), valueUser(totalAmount, 0, (claimedWXAmount + remainingAmount), height))]
127
+
                else [ScriptTransfer(addr, amount, wx), StringEntry(keyUser(address), valueUser(totalAmount, (remainingAmount - amount), (claimedWXAmount + amount), height))]
128
+
            }
129
+
        else throw("Strict value is not equal to itself.")
130
+
    }
131
+
132
+
109
133
 
@Callable(i)
110
134
 
func constructor (wxAssetId) = {
111
135
 
    let check = mustManager(i)
117
141
 
118
142
 
119
143
 
@Callable(i)
144
+
func withdrawRevoked () = {
145
+
    let amount = valueOrElse(getInteger(keyRevokedTotal()), 0)
146
+
    let wx = fromBase58String(value(getString(keyWxAssetId())))
147
+
    let checks = [mustManager(i), if ((amount > 0))
148
+
        then true
149
+
        else throwErr("revoked amount is zero, nothing to withdraw")]
150
+
    if ((checks == checks))
151
+
        then [ScriptTransfer(i.caller, amount, wx), IntegerEntry(keyRevokedTotal(), 0)]
152
+
        else throw("Strict value is not equal to itself.")
153
+
    }
154
+
155
+
156
+
157
+
@Callable(i)
120
158
 
func createDepositFor (address,blocksDuration) = {
159
+
    let amount = i.payments[0].amount
121
160
 
    let endHeight = (height + blocksDuration)
122
-
    let amount = i.payments[0].amount
123
161
 
    let vestingLen = (endHeight - height)
124
162
 
    let amountPerBlock = (amount / vestingLen)
125
163
 
    let checks = [mustManager(i), if ((endHeight > height))
139
177
 
140
178
 
141
179
 
@Callable(i)
142
-
func revokeDepositFor (address) = {
143
-
    let checks = [mustManager(i), if ((getString(keyUser(address)) != unit))
144
-
        then true
145
-
        else throwErr("deposit for user is not exists")]
146
-
    if ((checks == checks))
180
+
func increaseDepositFor (address) = {
181
+
    let availableToClaim = availableToClaimNow(address)
182
+
    let forceClaim = if ((availableToClaim > 0))
183
+
        then claimInternal(address)
184
+
        else unit
185
+
    if ((forceClaim == forceClaim))
147
186
 
        then {
148
-
            let totalAmount = getUserTotalAmount(address)
149
-
            let amount = availableToClaimNow(address)
150
-
            let claimedWXAmount = getUserClaimedAmount(address)
151
-
            let lastClaimedHeight = getUserLastClaimedHeight(address)
152
-
[BooleanEntry(keyRevoked(address), true), StringEntry(keyUser(address), valueUser(totalAmount, amount, claimedWXAmount, lastClaimedHeight))]
187
+
            let amount = i.payments[0].amount
188
+
            let endHeight = value(getInteger(keyUserVestingEnd(address)))
189
+
            let vestingLen = (endHeight - height)
190
+
            let amountPerBlock = value(getInteger(keyUserAmountPerBlock(address)))
191
+
            let incAmountPerBlock = (amount / vestingLen)
192
+
            let userTotalAmount = getUserTotalAmount(address)
193
+
            let userRemainingAmount = getUserRemainingAmount(address)
194
+
            let userClaimedAmount = getUserClaimedAmount(address)
195
+
            let userLastClaimedHeight = getUserLastClaimedHeight(address)
196
+
            let checks = [mustManager(i), if ((valueOrElse(getBoolean(keyRevoked(address)), false) == false))
197
+
                then true
198
+
                else throwErr("deposit for user is revoked"), if ((getString(keyUser(address)) != unit))
199
+
                then true
200
+
                else throwErr("deposit for user doesn't exists"), if ((toBase58String(value(i.payments[0].assetId)) == value(getString(keyWxAssetId()))))
201
+
                then true
202
+
                else throwErr("attached payment is not WX"), if ((incAmountPerBlock != 0))
203
+
                then true
204
+
                else throwErr("attached amount too small — increase is zero per block")]
205
+
            if ((checks == checks))
206
+
                then [StringEntry(keyUser(address), valueUser((userTotalAmount + amount), (userRemainingAmount + amount), userClaimedAmount, userLastClaimedHeight)), IntegerEntry(keyUserAmountPerBlock(address), (amountPerBlock + incAmountPerBlock))]
207
+
                else throw("Strict value is not equal to itself.")
153
208
 
            }
154
209
 
        else throw("Strict value is not equal to itself.")
155
210
 
    }
157
212
 
158
213
 
159
214
 
@Callable(i)
160
-
func claim () = {
161
-
    let addr = i.caller
162
-
    let addrStr = toString(addr)
163
-
    let wx = fromBase58String(value(getString(keyWxAssetId())))
164
-
    let amount = availableToClaimNow(addrStr)
165
-
    let ensureAmount = if ((amount != 0))
215
+
func revokeDepositFor (address) = {
216
+
    let totalAmount = getUserTotalAmount(address)
217
+
    let remainingAmount = getUserRemainingAmount(address)
218
+
    let claimedWXAmount = getUserClaimedAmount(address)
219
+
    let lastClaimedHeight = getUserLastClaimedHeight(address)
220
+
    let unclaimedAmountNow = availableToClaimNow(address)
221
+
    let revokedTotal = valueOrElse(getInteger(keyRevokedTotal()), 0)
222
+
    let amountToRevoke = (remainingAmount - unclaimedAmountNow)
223
+
    let newRevokedTotal = (revokedTotal + amountToRevoke)
224
+
    let checks = [mustManager(i), if ((getString(keyUser(address)) != unit))
166
225
 
        then true
167
-
        else throwErr("nothing to claim")
168
-
    if ((ensureAmount == ensureAmount))
169
-
        then {
170
-
            let totalAmount = getUserTotalAmount(addrStr)
171
-
            let remainingAmount = getUserRemainingAmount(addrStr)
172
-
            let claimedWXAmount = getUserClaimedAmount(addrStr)
173
-
            let isRevokedUser = valueOrElse(getBoolean(keyRevoked(addrStr)), false)
174
-
            if (isRevokedUser)
175
-
                then [ScriptTransfer(addr, remainingAmount, wx), StringEntry(keyUser(addrStr), valueUser(totalAmount, 0, (claimedWXAmount + remainingAmount), height))]
176
-
                else [ScriptTransfer(addr, amount, wx), StringEntry(keyUser(addrStr), valueUser(totalAmount, (remainingAmount - amount), (claimedWXAmount + amount), height))]
177
-
            }
226
+
        else throwErr("deposit for user is not exists"), if ((newRevokedTotal > revokedTotal))
227
+
        then true
228
+
        else throwErr("newRevokedTotal can't be less or equal than revokedTotal")]
229
+
    if ((checks == checks))
230
+
        then [BooleanEntry(keyRevoked(address), true), IntegerEntry(keyRevokedTotal(), newRevokedTotal), StringEntry(keyUser(address), valueUser(totalAmount, unclaimedAmountNow, claimedWXAmount, lastClaimedHeight))]
178
231
 
        else throw("Strict value is not equal to itself.")
179
232
 
    }
233
+
234
+
235
+
236
+
@Callable(i)
237
+
func claim () = claimInternal(toBase58String(i.caller.bytes))
180
238
 
181
239
 
182
240
 

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

github/deemru/w8io/026f985 
58.04 ms ◑