tx · 2WKUirVcMpQUDDokDWowue7hGuXqGuH2riBivzimqcN5

3Mx4GxjrawhKHBgMKH9C5Hmbj8ePZDrs8ed:  -0.01800000 Waves

2023.07.03 12:24 [2649543] smart account 3Mx4GxjrawhKHBgMKH9C5Hmbj8ePZDrs8ed > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2WKUirVcMpQUDDokDWowue7hGuXqGuH2riBivzimqcN5",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1688376132446,
    "version": 2,
    "chainId": 84,
    "sender": "3Mx4GxjrawhKHBgMKH9C5Hmbj8ePZDrs8ed",
    "senderPublicKey": "9DpEgmia9fGpxtGGDeSMtER4g9qB7WQPPYTKTHzqSFuX",
    "proofs": [
        "2S9W9z7FG3Htuj2F5wNg6ep5JuRJrSyp133Pekr9xFH8Bu79niBYBe2q8LCVoo3PH7xvDQ4uNbSfAh1hh3h7FdTC"
    ],
    "script": "base64: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",
    "height": 2649543,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: CutHDDT3ZWqnnsLpCRLmXhXX1GbbmRJseeNLkgQeUveE
Next: HQk1zzpFd1kqKkmmzkK3P4NjC9YomXh6g3Jtdg6PPGxA

Diff: 
Old
New
Differences
374
374
 
375
375
 
376
376
 
@Callable(i)
377
-
func burnTokens (executionChainId_,recipient_,referrer_,gaslessReward_) = {
377
+
func burnTokens (executionChainId_,recipient_,gaslessReward_) = {
378
378
 
    let err = if (if (if (if (if (_whenInitialized())
379
379
 
        then _whenNotPaused()
380
380
 
        else false)
496
496
 
                            let err2 = _validateInt(amount, (fee + 1), MAX_INT, "burnTokensV2: fee more than amount")
497
497
 
                            if ((err2 == err2))
498
498
 
                                then {
499
-
                                    let $t01622416629 = if ((referrer_ != ""))
499
+
                                    let $t01620116606 = if ((referrer_ != ""))
500
500
 
                                        then {
501
501
 
                                            let referrer = addressFromStringValue(referrer_)
502
502
 
                                            let referrerFeeAmount = fraction(_loadReferrerFeePercent(executionChainId_, referrer), fee, PERCENT_FACTOR)
503
503
 
                                            $Tuple2(referrerFeeAmount, [ScriptTransfer(referrer, referrerFeeAmount, assetId)])
504
504
 
                                            }
505
505
 
                                        else $Tuple2(0, nil)
506
-
                                    let referrerFee = $t01622416629._1
507
-
                                    let referrerActions = $t01622416629._2
506
+
                                    let referrerFee = $t01620116606._1
507
+
                                    let referrerActions = $t01620116606._2
508
508
 
                                    let amountToSend = (amount - fee)
509
509
 
                                    let err3 = _validateInt(amountToSend, (gaslessReward_ + 1), MAX_INT, "burnTokensV2: reward more than amount")
510
510
 
                                    if ((err3 == err3))
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEPARATOR = "__"
5
5
 
6
6
 
let KEY_INIT = "INIT"
7
7
 
8
8
 
let KEY_MULTISIG = "MULTISIG"
9
9
 
10
10
 
let KEY_STATUS = "STATUS"
11
11
 
12
12
 
let KEY_PAUSED = "PAUSED"
13
13
 
14
14
 
let KEY_PAUSER = "PAUSER"
15
15
 
16
16
 
let KEY_EXECUTOR = "EXECUTOR"
17
17
 
18
18
 
let KEY_ROOT_ADAPTER = "ROOT_ADAPTER"
19
19
 
20
20
 
let KEY_CALLER_CONTRACT = "CALLER_CONTRACT"
21
21
 
22
22
 
let KEY_CHAIN = "CHAIN"
23
23
 
24
24
 
let KEY_BINDING = "BINDING"
25
25
 
26
26
 
let KEY_FEE = "FEE"
27
27
 
28
28
 
let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
29
29
 
30
30
 
let KEY_REFERRER_FEE_PERCENT = "REFERRER_FEE_PERCENT"
31
31
 
32
32
 
let FUNC_RELEASE_TOKENS = "releaseTokens"
33
33
 
34
34
 
let WAVES = "WAVES"
35
35
 
36
36
 
let WAVES_DECIMALS = 8
37
37
 
38
38
 
let DECIMALS = 6
39
39
 
40
40
 
let PERCENT_FACTOR = 1000000
41
41
 
42
42
 
let MAX_REFERRER_FEE = 200000
43
43
 
44
44
 
let MAX_INT = 9223372036854775807
45
45
 
46
46
 
func _validateAddress (address_,err_) = match addressFromString(address_) {
47
47
 
    case a: Address => 
48
48
 
        true
49
49
 
    case _ => 
50
50
 
        throw(err_)
51
51
 
}
52
52
 
53
53
 
54
54
 
func _validateAsset (assetId_,err_) = match assetInfo(fromBase58String(assetId_)) {
55
55
 
    case a: Asset => 
56
56
 
        true
57
57
 
    case _ => 
58
58
 
        throw(err_)
59
59
 
}
60
60
 
61
61
 
62
62
 
func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
63
63
 
    then true
64
64
 
    else (val_ > upperBoundary_))
65
65
 
    then throw(err_)
66
66
 
    else true
67
67
 
68
68
 
69
69
 
func _validateBool (val_,target_,err_) = if ((val_ != target_))
70
70
 
    then throw(err_)
71
71
 
    else true
72
72
 
73
73
 
74
74
 
func _validatePaymentsSize (payments_,target_,err_) = if ((size(payments_) != target_))
75
75
 
    then throw(err_)
76
76
 
    else true
77
77
 
78
78
 
79
79
 
func _validateReferrer (referrer_,err_) = if ((referrer_ != ""))
80
80
 
    then _validateAddress(referrer_, err_)
81
81
 
    else true
82
82
 
83
83
 
84
84
 
func _normalizeDecimals (amount_,sourceDecimals_,targetDecimals_) = if ((sourceDecimals_ >= targetDecimals_))
85
85
 
    then (amount_ / pow(10, 0, (sourceDecimals_ - targetDecimals_), 0, 0, DOWN))
86
86
 
    else (amount_ * pow(10, 0, (targetDecimals_ - sourceDecimals_), 0, 0, DOWN))
87
87
 
88
88
 
89
89
 
func _loadInit () = match getBoolean(KEY_INIT) {
90
90
 
    case a: Boolean => 
91
91
 
        a
92
92
 
    case _ => 
93
93
 
        false
94
94
 
}
95
95
 
96
96
 
97
97
 
func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
98
98
 
99
99
 
100
100
 
func _loadPause () = match getBoolean(KEY_PAUSED) {
101
101
 
    case a: Boolean => 
102
102
 
        a
103
103
 
    case _ => 
104
104
 
        false
105
105
 
}
106
106
 
107
107
 
108
108
 
func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
109
109
 
110
110
 
111
111
 
func _loadPauser () = match getString(KEY_PAUSER) {
112
112
 
    case a: String => 
113
113
 
        addressFromStringValue(a)
114
114
 
    case _ => 
115
115
 
        Address(base58'')
116
116
 
}
117
117
 
118
118
 
119
119
 
func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
120
120
 
121
121
 
122
122
 
func _loadMultisig () = match getString(KEY_MULTISIG) {
123
123
 
    case a: String => 
124
124
 
        addressFromStringValue(a)
125
125
 
    case _ => 
126
126
 
        Address(base58'')
127
127
 
}
128
128
 
129
129
 
130
130
 
func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
131
131
 
132
132
 
133
133
 
func _loadExecutor () = match getString(KEY_EXECUTOR) {
134
134
 
    case a: String => 
135
135
 
        addressFromStringValue(a)
136
136
 
    case _ => 
137
137
 
        Address(base58'')
138
138
 
}
139
139
 
140
140
 
141
141
 
func _saveExecutor (executor_) = [StringEntry(KEY_EXECUTOR, toString(executor_))]
142
142
 
143
143
 
144
144
 
func _loadCallerContract () = match getString(KEY_CALLER_CONTRACT) {
145
145
 
    case a: String => 
146
146
 
        a
147
147
 
    case _ => 
148
148
 
        ""
149
149
 
}
150
150
 
151
151
 
152
152
 
func _saveCallerContract (caller_) = [StringEntry(KEY_CALLER_CONTRACT, caller_)]
153
153
 
154
154
 
155
155
 
func _loadChain (chainId_) = match getBoolean(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR)) {
156
156
 
    case a: Boolean => 
157
157
 
        a
158
158
 
    case _ => 
159
159
 
        false
160
160
 
}
161
161
 
162
162
 
163
163
 
func _saveChain (chainId_,val_) = [BooleanEntry(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR), val_)]
164
164
 
165
165
 
166
166
 
func _loadBinding (executionChainId_,assetId_) = match getString(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR)) {
167
167
 
    case a: String => 
168
168
 
        let struct = split(a, SEPARATOR)
169
169
 
        $Tuple8(addressFromStringValue(struct[0]), struct[1], parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), parseIntValue(struct[5]), parseIntValue(struct[6]), if ((struct[7] == "1"))
170
170
 
            then true
171
171
 
            else false)
172
172
 
    case _ => 
173
173
 
        $Tuple8(Address(base58''), "", 0, 0, 0, 0, 0, false)
174
174
 
}
175
175
 
176
176
 
177
177
 
func _saveBinding (executionChainId_,assetId_,binding_) = [StringEntry(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR), makeString([toString(binding_._1), binding_._2, toString(binding_._3), toString(binding_._4), toString(binding_._5), toString(binding_._6), toString(binding_._7), if (binding_._8)
178
178
 
    then "1"
179
179
 
    else "0"], SEPARATOR))]
180
180
 
181
181
 
182
182
 
func _loadFee (assetId_) = match getInteger(makeString([KEY_FEE, toBase58String(assetId_)], SEPARATOR)) {
183
183
 
    case a: Int => 
184
184
 
        a
185
185
 
    case _ => 
186
186
 
        0
187
187
 
}
188
188
 
189
189
 
190
190
 
func _saveFee (assetId_,val_) = [IntegerEntry(makeString([KEY_FEE, toBase58String(assetId_)], SEPARATOR), val_)]
191
191
 
192
192
 
193
193
 
func _loadRootAdapter () = match getString(KEY_ROOT_ADAPTER) {
194
194
 
    case a: String => 
195
195
 
        addressFromStringValue(a)
196
196
 
    case _ => 
197
197
 
        Address(base58'')
198
198
 
}
199
199
 
200
200
 
201
201
 
func _saveRootAdapter (adapter_) = [StringEntry(KEY_ROOT_ADAPTER, toString(adapter_))]
202
202
 
203
203
 
204
204
 
func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
205
205
 
    case a: String => 
206
206
 
        addressFromStringValue(a)
207
207
 
    case _ => 
208
208
 
        Address(base58'')
209
209
 
}
210
210
 
211
211
 
212
212
 
func _saveFeeRecipient (val_) = [StringEntry(KEY_FEE_RECIPIENT, toString(val_))]
213
213
 
214
214
 
215
215
 
func _loadReferrerFeePercent (executionChainId_,referrer_) = match getInteger(makeString([KEY_REFERRER_FEE_PERCENT, toString(executionChainId_), toString(referrer_)], SEPARATOR)) {
216
216
 
    case a: Int => 
217
217
 
        a
218
218
 
    case _ => 
219
219
 
        0
220
220
 
}
221
221
 
222
222
 
223
223
 
func _saveReferrerFeePercent (executionChainId_,referrer_,val_) = [IntegerEntry(makeString([KEY_REFERRER_FEE_PERCENT, toString(executionChainId_), toString(referrer_)], SEPARATOR), val_)]
224
224
 
225
225
 
226
226
 
func _onlyThisContract (caller_) = if ((caller_ != this))
227
227
 
    then throw("_onlyThisContract: revert")
228
228
 
    else true
229
229
 
230
230
 
231
231
 
func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
232
232
 
    then throw("_whenMultisigSet: revert")
233
233
 
    else true
234
234
 
235
235
 
236
236
 
func _whenNotInitialized () = if (_loadInit())
237
237
 
    then throw("_whenNotInitialized: revert")
238
238
 
    else true
239
239
 
240
240
 
241
241
 
func _whenInitialized () = if (!(_loadInit()))
242
242
 
    then throw("_whenInitialized: revert")
243
243
 
    else true
244
244
 
245
245
 
246
246
 
func _whenNotPaused () = if (_loadPause())
247
247
 
    then throw("_whenNotPaused: revert")
248
248
 
    else true
249
249
 
250
250
 
251
251
 
func _whenPaused () = if (!(_loadPause()))
252
252
 
    then throw("_whenPaused: revert")
253
253
 
    else true
254
254
 
255
255
 
256
256
 
func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
257
257
 
    then throw("_onlyPauser: revert")
258
258
 
    else true
259
259
 
260
260
 
261
261
 
func _asInt (val_) = match val_ {
262
262
 
    case a: Int => 
263
263
 
        a
264
264
 
    case _ => 
265
265
 
        throw("_asInt: revert")
266
266
 
}
267
267
 
268
268
 
269
269
 
func _asBytes (val_) = match val_ {
270
270
 
    case a: ByteVector => 
271
271
 
        a
272
272
 
    case _ => 
273
273
 
        throw("_asBytes: revert")
274
274
 
}
275
275
 
276
276
 
277
277
 
func _validateExecutor (val_,err_) = if ((val_ != _loadExecutor()))
278
278
 
    then throw(err_)
279
279
 
    else true
280
280
 
281
281
 
282
282
 
func _validateCaller (val_,err_) = if ((val_ != _loadCallerContract()))
283
283
 
    then throw(err_)
284
284
 
    else true
285
285
 
286
286
 
287
287
 
func _validateChain (executionChainId_,err_) = if (!(_loadChain(executionChainId_)))
288
288
 
    then throw(err_)
289
289
 
    else true
290
290
 
291
291
 
292
292
 
@Callable(i)
293
293
 
func init (executor_,adapter_,pauser_,feeRecipient_) = {
294
294
 
    let err = if (if (if (if (if (if (_onlyThisContract(i.caller))
295
295
 
        then _whenNotInitialized()
296
296
 
        else false)
297
297
 
        then _whenMultisigSet()
298
298
 
        else false)
299
299
 
        then _validateAddress(executor_, "init: invalid executor")
300
300
 
        else false)
301
301
 
        then _validateAddress(adapter_, "init: invalid adapter")
302
302
 
        else false)
303
303
 
        then _validateAddress(pauser_, "init: invalid pauser")
304
304
 
        else false)
305
305
 
        then _validateAddress(feeRecipient_, "init: invalid feeRecipient")
306
306
 
        else false
307
307
 
    if ((err == err))
308
308
 
        then $Tuple2(((((_saveInit(true) ++ _saveExecutor(addressFromStringValue(executor_))) ++ _saveRootAdapter(addressFromStringValue(adapter_))) ++ _savePauser(addressFromStringValue(pauser_))) ++ _saveFeeRecipient(addressFromStringValue(feeRecipient_))), unit)
309
309
 
        else throw("Strict value is not equal to itself.")
310
310
 
    }
311
311
 
312
312
 
313
313
 
314
314
 
@Callable(i)
315
315
 
func mintTokens (callerContract_,assetContract_,amount_,recipient_,gaslessReward_,referrer_,referrerFee_) = {
316
316
 
    let amount = valueOrErrorMessage(parseInt(amount_), "mint: amount is not Int")
317
317
 
    let gaslessReward = valueOrErrorMessage(parseInt(gaslessReward_), "mint: gaslessReward is not Int")
318
318
 
    let referrerFee = valueOrErrorMessage(parseInt(referrerFee_), "mint: referrerFee is not Int")
319
319
 
    let err = if (if (if (if (if (if (if (if (_whenInitialized())
320
320
 
        then _whenNotPaused()
321
321
 
        else false)
322
322
 
        then _validateAddress(assetContract_, "mint: invalid asset contract")
323
323
 
        else false)
324
324
 
        then _validateExecutor(i.caller, "mint: invalid executor")
325
325
 
        else false)
326
326
 
        then _validateCaller(callerContract_, "mint: invalid caller")
327
327
 
        else false)
328
328
 
        then _validateAddress(recipient_, "mint: invalid recipient address")
329
329
 
        else false)
330
330
 
        then _validateInt(amount, 0, MAX_INT, "mint: invalid amount")
331
331
 
        else false)
332
332
 
        then _validateInt(gaslessReward, 0, MAX_INT, "mint: invalid gaslessReward")
333
333
 
        else false)
334
334
 
        then _validateInt(referrerFee, 0, MAX_INT, "mint: invalid referrer fee")
335
335
 
        else false
336
336
 
    if ((err == err))
337
337
 
        then {
338
338
 
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
339
339
 
            if ((assetId == assetId))
340
340
 
                then {
341
341
 
                    let assetDecimals = _asInt(invoke(addressFromStringValue(assetContract_), "getDecimals", nil, nil))
342
342
 
                    if ((assetDecimals == assetDecimals))
343
343
 
                        then {
344
344
 
                            let normalizedAmount = _normalizeDecimals(amount, DECIMALS, assetDecimals)
345
345
 
                            let normalizedGasless = _normalizeDecimals(gaslessReward, DECIMALS, assetDecimals)
346
346
 
                            let referrer =                             match addressFromString(referrer_) {
347
347
 
                                case refererAddress: Address => 
348
348
 
                                    let normalizedReferrerFee = _normalizeDecimals(referrerFee, DECIMALS, assetDecimals)
349
349
 
                                    $Tuple2(normalizedReferrerFee, [ScriptTransfer(refererAddress, normalizedReferrerFee, assetId)])
350
350
 
                                case _ => 
351
351
 
                                    $Tuple2(0, nil)
352
352
 
                            }
353
353
 
                            let normalizedReferrerFee = referrer._1
354
354
 
                            let referrerActions = referrer._2
355
355
 
                            let invocation = invoke(addressFromStringValue(assetContract_), "mint", [(normalizedAmount + normalizedReferrerFee), toString(this)], nil)
356
356
 
                            if ((invocation == invocation))
357
357
 
                                then {
358
358
 
                                    let actions = if (if ((normalizedGasless > 0))
359
359
 
                                        then (addressFromStringValue(recipient_) != i.originCaller)
360
360
 
                                        else false)
361
361
 
                                        then [ScriptTransfer(addressFromStringValue(recipient_), (normalizedAmount - normalizedGasless), assetId), ScriptTransfer(i.originCaller, normalizedGasless, assetId)]
362
362
 
                                        else [ScriptTransfer(addressFromStringValue(recipient_), normalizedAmount, assetId)]
363
363
 
                                    $Tuple2((actions ++ referrerActions), unit)
364
364
 
                                    }
365
365
 
                                else throw("Strict value is not equal to itself.")
366
366
 
                            }
367
367
 
                        else throw("Strict value is not equal to itself.")
368
368
 
                    }
369
369
 
                else throw("Strict value is not equal to itself.")
370
370
 
            }
371
371
 
        else throw("Strict value is not equal to itself.")
372
372
 
    }
373
373
 
374
374
 
375
375
 
376
376
 
@Callable(i)
377
-
func burnTokens (executionChainId_,recipient_,referrer_,gaslessReward_) = {
377
+
func burnTokens (executionChainId_,recipient_,gaslessReward_) = {
378
378
 
    let err = if (if (if (if (if (_whenInitialized())
379
379
 
        then _whenNotPaused()
380
380
 
        else false)
381
381
 
        then _validateChain(executionChainId_, "burnTokens: invalid execution chain")
382
382
 
        else false)
383
383
 
        then _validatePaymentsSize(i.payments, 1, "burnTokens: no payment")
384
384
 
        else false)
385
385
 
        then _validateInt(gaslessReward_, 0, MAX_INT, "burnTokens: invalid gaslessReward")
386
386
 
        else false)
387
387
 
        then _validateInt(i.payments[0].amount, 0, MAX_INT, "burnTokens: invalid payment amount")
388
388
 
        else false
389
389
 
    if ((err == err))
390
390
 
        then {
391
391
 
            let amount = i.payments[0].amount
392
392
 
            let assetId =             match i.payments[0].assetId {
393
393
 
                case a: ByteVector => 
394
394
 
                    a
395
395
 
                case _ => 
396
396
 
                    throw("burnTokens: invalid asset")
397
397
 
            }
398
398
 
            let binding = _loadBinding(executionChainId_, assetId)
399
399
 
            let assetContract = binding._1
400
400
 
            let executionAsset = binding._2
401
401
 
            let minAmount = binding._3
402
402
 
            let minFee = binding._4
403
403
 
            let thresholdFee = binding._5
404
404
 
            let beforePercentFee = binding._6
405
405
 
            let afterPercentFee = binding._7
406
406
 
            let enabled = binding._8
407
407
 
            let err1 = if (if (_validateAddress(toString(assetContract), "burnTokens: no such binding"))
408
408
 
                then _validateInt(amount, minAmount, MAX_INT, "burnTokens: less than min")
409
409
 
                else false)
410
410
 
                then _validateBool(enabled, true, "burnTokens: token is disabled")
411
411
 
                else false
412
412
 
            if ((err1 == err1))
413
413
 
                then {
414
414
 
                    let assetDecimals = _asInt(invoke(assetContract, "getDecimals", nil, nil))
415
415
 
                    if ((assetDecimals == assetDecimals))
416
416
 
                        then {
417
417
 
                            let percent = if ((amount > thresholdFee))
418
418
 
                                then afterPercentFee
419
419
 
                                else beforePercentFee
420
420
 
                            let fee = (minFee + fraction(amount, percent, PERCENT_FACTOR))
421
421
 
                            let err2 = _validateInt(amount, (fee + 1), MAX_INT, "burnTokens: fee more than amount")
422
422
 
                            if ((err2 == err2))
423
423
 
                                then {
424
424
 
                                    let amountToSend = (amount - fee)
425
425
 
                                    let err3 = _validateInt(amountToSend, (gaslessReward_ + 1), MAX_INT, "burnTokens: reward more than amount")
426
426
 
                                    if ((err3 == err3))
427
427
 
                                        then {
428
428
 
                                            let updateFee = (_loadFee(assetId) + fee)
429
429
 
                                            let normalizedAmount = _normalizeDecimals(amountToSend, assetDecimals, DECIMALS)
430
430
 
                                            let normalizedGasless = _normalizeDecimals(gaslessReward_, assetDecimals, DECIMALS)
431
431
 
                                            let invocation = invoke(_loadRootAdapter(), FUNC_RELEASE_TOKENS, [executionChainId_, executionAsset, normalizedAmount, recipient_, normalizedGasless], nil)
432
432
 
                                            if ((invocation == invocation))
433
433
 
                                                then $Tuple2((_saveFee(assetId, updateFee) ++ [Burn(assetId, amountToSend)]), unit)
434
434
 
                                                else throw("Strict value is not equal to itself.")
435
435
 
                                            }
436
436
 
                                        else throw("Strict value is not equal to itself.")
437
437
 
                                    }
438
438
 
                                else throw("Strict value is not equal to itself.")
439
439
 
                            }
440
440
 
                        else throw("Strict value is not equal to itself.")
441
441
 
                    }
442
442
 
                else throw("Strict value is not equal to itself.")
443
443
 
            }
444
444
 
        else throw("Strict value is not equal to itself.")
445
445
 
    }
446
446
 
447
447
 
448
448
 
449
449
 
@Callable(i)
450
450
 
func burnTokensV2 (executionChainId_,recipient_,referrer_,gaslessReward_) = {
451
451
 
    let err = if (if (if (if (if (if (_whenInitialized())
452
452
 
        then _whenNotPaused()
453
453
 
        else false)
454
454
 
        then _validateChain(executionChainId_, "burnTokensV2: invalid execution chain")
455
455
 
        else false)
456
456
 
        then _validatePaymentsSize(i.payments, 1, "burnTokensV2: no payment")
457
457
 
        else false)
458
458
 
        then _validateInt(gaslessReward_, 0, MAX_INT, "burnTokensV2: invalid gaslessReward")
459
459
 
        else false)
460
460
 
        then _validateInt(i.payments[0].amount, 0, MAX_INT, "burnTokensV2: invalid payment amount")
461
461
 
        else false)
462
462
 
        then _validateReferrer(referrer_, "burnTokensV2: invalid referrer")
463
463
 
        else false
464
464
 
    if ((err == err))
465
465
 
        then {
466
466
 
            let amount = i.payments[0].amount
467
467
 
            let assetId =             match i.payments[0].assetId {
468
468
 
                case a: ByteVector => 
469
469
 
                    a
470
470
 
                case _ => 
471
471
 
                    throw("burnTokensV2: invalid asset")
472
472
 
            }
473
473
 
            let binding = _loadBinding(executionChainId_, assetId)
474
474
 
            let assetContract = binding._1
475
475
 
            let executionAsset = binding._2
476
476
 
            let minAmount = binding._3
477
477
 
            let minFee = binding._4
478
478
 
            let thresholdFee = binding._5
479
479
 
            let beforePercentFee = binding._6
480
480
 
            let afterPercentFee = binding._7
481
481
 
            let enabled = binding._8
482
482
 
            let err1 = if (if (_validateAddress(toString(assetContract), "burnTokensV2: no such binding"))
483
483
 
                then _validateInt(amount, minAmount, MAX_INT, "burnTokensV2: less than min")
484
484
 
                else false)
485
485
 
                then _validateBool(enabled, true, "burnTokensV2: token is disabled")
486
486
 
                else false
487
487
 
            if ((err1 == err1))
488
488
 
                then {
489
489
 
                    let assetDecimals = _asInt(invoke(assetContract, "getDecimals", nil, nil))
490
490
 
                    if ((assetDecimals == assetDecimals))
491
491
 
                        then {
492
492
 
                            let percent = if ((amount > thresholdFee))
493
493
 
                                then afterPercentFee
494
494
 
                                else beforePercentFee
495
495
 
                            let fee = (minFee + fraction(amount, percent, PERCENT_FACTOR))
496
496
 
                            let err2 = _validateInt(amount, (fee + 1), MAX_INT, "burnTokensV2: fee more than amount")
497
497
 
                            if ((err2 == err2))
498
498
 
                                then {
499
-
                                    let $t01622416629 = if ((referrer_ != ""))
499
+
                                    let $t01620116606 = if ((referrer_ != ""))
500
500
 
                                        then {
501
501
 
                                            let referrer = addressFromStringValue(referrer_)
502
502
 
                                            let referrerFeeAmount = fraction(_loadReferrerFeePercent(executionChainId_, referrer), fee, PERCENT_FACTOR)
503
503
 
                                            $Tuple2(referrerFeeAmount, [ScriptTransfer(referrer, referrerFeeAmount, assetId)])
504
504
 
                                            }
505
505
 
                                        else $Tuple2(0, nil)
506
-
                                    let referrerFee = $t01622416629._1
507
-
                                    let referrerActions = $t01622416629._2
506
+
                                    let referrerFee = $t01620116606._1
507
+
                                    let referrerActions = $t01620116606._2
508
508
 
                                    let amountToSend = (amount - fee)
509
509
 
                                    let err3 = _validateInt(amountToSend, (gaslessReward_ + 1), MAX_INT, "burnTokensV2: reward more than amount")
510
510
 
                                    if ((err3 == err3))
511
511
 
                                        then {
512
512
 
                                            let updateFee = ((_loadFee(assetId) + fee) - referrerFee)
513
513
 
                                            let normalizedAmount = _normalizeDecimals(amountToSend, assetDecimals, DECIMALS)
514
514
 
                                            let normalizedGasless = _normalizeDecimals(gaslessReward_, assetDecimals, DECIMALS)
515
515
 
                                            let invocation = invoke(_loadRootAdapter(), FUNC_RELEASE_TOKENS, [executionChainId_, executionAsset, normalizedAmount, recipient_, normalizedGasless], nil)
516
516
 
                                            if ((invocation == invocation))
517
517
 
                                                then $Tuple2(((_saveFee(assetId, updateFee) ++ referrerActions) ++ [Burn(assetId, amountToSend)]), unit)
518
518
 
                                                else throw("Strict value is not equal to itself.")
519
519
 
                                            }
520
520
 
                                        else throw("Strict value is not equal to itself.")
521
521
 
                                    }
522
522
 
                                else throw("Strict value is not equal to itself.")
523
523
 
                            }
524
524
 
                        else throw("Strict value is not equal to itself.")
525
525
 
                    }
526
526
 
                else throw("Strict value is not equal to itself.")
527
527
 
            }
528
528
 
        else throw("Strict value is not equal to itself.")
529
529
 
    }
530
530
 
531
531
 
532
532
 
533
533
 
@Callable(i)
534
534
 
func transferFee (executionChainId_,assetId_) = {
535
535
 
    let err = if (if (_whenInitialized())
536
536
 
        then _whenNotPaused()
537
537
 
        else false)
538
538
 
        then _validateAsset(assetId_, "transferFee: invalid asset")
539
539
 
        else false
540
540
 
    if ((err == err))
541
541
 
        then {
542
542
 
            let assetId = fromBase58String(assetId_)
543
543
 
            let binding = _loadBinding(executionChainId_, assetId)
544
544
 
            let assetContract = binding._1
545
545
 
            let enabled = binding._8
546
546
 
            let err1 = if (_validateAddress(toString(assetContract), "transferFee: no such binding"))
547
547
 
                then _validateBool(enabled, true, "transferFee: token is disabled")
548
548
 
                else false
549
549
 
            if ((err1 == err1))
550
550
 
                then $Tuple2((_saveFee(assetId, 0) ++ [ScriptTransfer(_loadFeeRecipient(), _loadFee(assetId), assetId)]), unit)
551
551
 
                else throw("Strict value is not equal to itself.")
552
552
 
            }
553
553
 
        else throw("Strict value is not equal to itself.")
554
554
 
    }
555
555
 
556
556
 
557
557
 
558
558
 
@Callable(i)
559
559
 
func updateCallerContract (callerContract_) = {
560
560
 
    let err = if (_onlyThisContract(i.caller))
561
561
 
        then _whenInitialized()
562
562
 
        else false
563
563
 
    if ((err == err))
564
564
 
        then $Tuple2(_saveCallerContract(callerContract_), unit)
565
565
 
        else throw("Strict value is not equal to itself.")
566
566
 
    }
567
567
 
568
568
 
569
569
 
570
570
 
@Callable(i)
571
571
 
func updateExecutionChain (executionChainId_,enabled_) = {
572
572
 
    let err = if (if (_onlyThisContract(i.caller))
573
573
 
        then _whenInitialized()
574
574
 
        else false)
575
575
 
        then _validateInt(executionChainId_, 0, MAX_INT, "updateExecutionChain: invalid executionChainId")
576
576
 
        else false
577
577
 
    if ((err == err))
578
578
 
        then $Tuple2(_saveChain(executionChainId_, enabled_), unit)
579
579
 
        else throw("Strict value is not equal to itself.")
580
580
 
    }
581
581
 
582
582
 
583
583
 
584
584
 
@Callable(i)
585
585
 
func updateFeeRecipient (feeRecipient_) = {
586
586
 
    let err = if (if (_onlyThisContract(i.caller))
587
587
 
        then _whenInitialized()
588
588
 
        else false)
589
589
 
        then _validateAddress(feeRecipient_, "updateFeeRecipient: invalid feeRecipient")
590
590
 
        else false
591
591
 
    if ((err == err))
592
592
 
        then $Tuple2(_saveFeeRecipient(addressFromStringValue(feeRecipient_)), unit)
593
593
 
        else throw("Strict value is not equal to itself.")
594
594
 
    }
595
595
 
596
596
 
597
597
 
598
598
 
@Callable(i)
599
599
 
func updateReferrer (executionChainId_,referrer_,fee_) = {
600
600
 
    let err = if (if (if (if (_onlyThisContract(i.caller))
601
601
 
        then _whenInitialized()
602
602
 
        else false)
603
603
 
        then _validateChain(executionChainId_, "updateReferrer: invalid execution chain")
604
604
 
        else false)
605
605
 
        then _validateAddress(referrer_, "updateReferrer: invalid referrer")
606
606
 
        else false)
607
607
 
        then _validateInt(fee_, 0, MAX_REFERRER_FEE, "updateReferrer: invalid fee")
608
608
 
        else false
609
609
 
    if ((err == err))
610
610
 
        then $Tuple2(_saveReferrerFeePercent(executionChainId_, addressFromStringValue(referrer_), fee_), unit)
611
611
 
        else throw("Strict value is not equal to itself.")
612
612
 
    }
613
613
 
614
614
 
615
615
 
616
616
 
@Callable(i)
617
617
 
func updateBindingInfo (executionChainId_,assetContract_,executionAsset_,minAmount_,minFee_,thresholdFee_,beforePercentFee_,afterPercentFee_,enabled_) = {
618
618
 
    let err = if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
619
619
 
        then _whenInitialized()
620
620
 
        else false)
621
621
 
        then _validateAddress(assetContract_, "updateBindingInfo: invalid asset contract")
622
622
 
        else false)
623
623
 
        then _validateInt(executionChainId_, 0, MAX_INT, "updateBindingInfo: invalid executionChainId")
624
624
 
        else false)
625
625
 
        then _validateInt(minAmount_, 0, MAX_INT, "updateBindingInfo: invalid minAmount")
626
626
 
        else false)
627
627
 
        then _validateInt(minFee_, 0, MAX_INT, "updateBindingInfo: invalid minFee")
628
628
 
        else false)
629
629
 
        then _validateInt(thresholdFee_, 0, MAX_INT, "updateBindingInfo: invalid thresholdFee")
630
630
 
        else false)
631
631
 
        then _validateInt(beforePercentFee_, 0, MAX_INT, "updateBindingInfo: invalid beforePercentFee")
632
632
 
        else false)
633
633
 
        then _validateInt(afterPercentFee_, 0, MAX_INT, "updateBindingInfo: invalid afterPercentFee")
634
634
 
        else false
635
635
 
    if ((err == err))
636
636
 
        then {
637
637
 
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
638
638
 
            if ((assetId == assetId))
639
639
 
                then {
640
640
 
                    let binding = $Tuple8(addressFromStringValue(assetContract_), executionAsset_, minAmount_, minFee_, thresholdFee_, beforePercentFee_, afterPercentFee_, enabled_)
641
641
 
                    $Tuple2(_saveBinding(executionChainId_, assetId, binding), unit)
642
642
 
                    }
643
643
 
                else throw("Strict value is not equal to itself.")
644
644
 
            }
645
645
 
        else throw("Strict value is not equal to itself.")
646
646
 
    }
647
647
 
648
648
 
649
649
 
650
650
 
@Callable(i)
651
651
 
func pause () = {
652
652
 
    let err = if (if (_onlyPauser(i.caller))
653
653
 
        then _whenInitialized()
654
654
 
        else false)
655
655
 
        then _whenNotPaused()
656
656
 
        else false
657
657
 
    if ((err == err))
658
658
 
        then $Tuple2(_savePause(true), unit)
659
659
 
        else throw("Strict value is not equal to itself.")
660
660
 
    }
661
661
 
662
662
 
663
663
 
664
664
 
@Callable(i)
665
665
 
func unpause () = {
666
666
 
    let err = if (if (_onlyPauser(i.caller))
667
667
 
        then _whenInitialized()
668
668
 
        else false)
669
669
 
        then _whenPaused()
670
670
 
        else false
671
671
 
    if ((err == err))
672
672
 
        then $Tuple2(_savePause(false), unit)
673
673
 
        else throw("Strict value is not equal to itself.")
674
674
 
    }
675
675
 
676
676
 
677
677
 
678
678
 
@Callable(i)
679
679
 
func updatePauser (pauser_) = {
680
680
 
    let err = if (if (_onlyThisContract(i.caller))
681
681
 
        then _whenInitialized()
682
682
 
        else false)
683
683
 
        then _validateAddress(pauser_, "updatePauser: invalid pauser")
684
684
 
        else false
685
685
 
    if ((err == err))
686
686
 
        then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
687
687
 
        else throw("Strict value is not equal to itself.")
688
688
 
    }
689
689
 
690
690
 
691
691
 
692
692
 
@Callable(i)
693
693
 
func setMultisig (multisig_) = {
694
694
 
    let err = if (_onlyThisContract(i.caller))
695
695
 
        then _validateAddress(multisig_, "setMultisig: invalid multisig")
696
696
 
        else false
697
697
 
    if ((err == err))
698
698
 
        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
699
699
 
        else throw("Strict value is not equal to itself.")
700
700
 
    }
701
701
 
702
702
 
703
703
 
@Verifier(tx)
704
704
 
func verify () = match getString(KEY_MULTISIG) {
705
705
 
    case multisig: String => 
706
706
 
        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
707
707
 
    case _ => 
708
708
 
        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
709
709
 
}
710
710
 

github/deemru/w8io/026f985 
73.92 ms ◑