tx · 8BZtmbAJyhrRnuMJDKjgy3P9gScSui6wsFKcJoUywNBh

3Mpwh8Q1gGv6gwtzViR9mgruFyy6Jdm4GCG:  -0.04200000 Waves

2024.12.20 10:25 [3422553] smart account 3Mpwh8Q1gGv6gwtzViR9mgruFyy6Jdm4GCG > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8BZtmbAJyhrRnuMJDKjgy3P9gScSui6wsFKcJoUywNBh",
    "fee": 4200000,
    "feeAssetId": null,
    "timestamp": 1734679566289,
    "version": 2,
    "chainId": 84,
    "sender": "3Mpwh8Q1gGv6gwtzViR9mgruFyy6Jdm4GCG",
    "senderPublicKey": "FLnBQATnBGWeMDB5MhixoEef8W61cnZUFXeCcwWAWQaR",
    "proofs": [
        "4491qjBuSZbKp1faHke3StBdBsLdDXAHtGtBEGotY6qbDb1n2ve7fTK8xdxgR5b44CmdN3KUigcUHfWFrSoFH4yC"
    ],
    "script": "base64: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",
    "height": 3422553,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 73ikuEeWgxYdou33Afud9GkKLeA5JEEHdAWxGfRnvEXD
Next: none

Diff: 
Old
New
Differences
76
76
 
77
77
 
78
78
 
func keyAssetDescription (assetId) = makeString(["%s%s", "assetDescription", assetId], SEP)
79
+
80
+
81
+
func keyMemePoolFactory () = makeString(["%s", "memePoolFactory"], SEP)
79
82
 
80
83
 
81
84
 
func getValueOrFail (address,key,type) = {
175
178
 
176
179
 
177
180
 
func isCreated (assetId) = valueOrElse(getBoolean(keyCreated(assetId)), false)
181
+
182
+
183
+
func isMemePoolFactory (i) = match getString(this, keyFactoryContract()) {
184
+
    case factoryAddress: String => 
185
+
        match addressFromString(factoryAddress) {
186
+
            case factoryContract: Address => 
187
+
                match getString(factoryContract, keyMemePoolFactory()) {
188
+
                    case memePoolFactoryAddress: String => 
189
+
                        (toString(i.caller) == memePoolFactoryAddress)
190
+
                    case _ => 
191
+
                        false
192
+
                }
193
+
            case _ => 
194
+
                false
195
+
        }
196
+
    case _ => 
197
+
        false
198
+
}
178
199
 
179
200
 
180
201
 
func verifiedToStatus (verified) = if (verified)
409
430
 
410
431
 
@Callable(i)
411
432
 
func createOrUpdate (assetId,logo,verified) = {
412
-
    let checkCaller = mustAdmin(i)
433
+
    let checkCaller = if (isMemePoolFactory(i))
434
+
        then true
435
+
        else mustAdmin(i)
413
436
 
    if ((checkCaller == checkCaller))
414
437
 
        then {
415
438
 
            let isCreatedNow = !(isCreated(assetId))
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
 
let statusVerified = 2
9
9
 
10
10
 
let statusUnverified = 0
11
11
 
12
12
 
let labelCommunityVerified = "COMMUNITY_VERIFIED"
13
13
 
14
14
 
let labelPoolsLp = "POOLS_LP"
15
15
 
16
16
 
let defaultLabels = [labelCommunityVerified, labelPoolsLp]
17
17
 
18
18
 
func throwPD () = throw("Permission denied")
19
19
 
20
20
 
21
21
 
func throwNoAsset () = throw("Asset doesn't exists")
22
22
 
23
23
 
24
24
 
func throwInvalidTicker () = throw("Invalid ticker")
25
25
 
26
26
 
27
27
 
func keyAdminPubKeys () = "%s__adminPubKeys"
28
28
 
29
29
 
30
30
 
func keyUserPoolsContract () = "%s__userPoolsContract"
31
31
 
32
32
 
33
33
 
func keyFactoryContract () = "%s__factoryContract"
34
34
 
35
35
 
36
36
 
func keyCreated (assetId) = (("created_<" + assetId) + ">")
37
37
 
38
38
 
39
39
 
func keyLogo (assetId) = (("logo_<" + assetId) + ">")
40
40
 
41
41
 
42
42
 
func keyTicker (assetId) = (("ticker_<" + assetId) + ">")
43
43
 
44
44
 
45
45
 
func keyStatus (assetId) = (("status_<" + assetId) + ">")
46
46
 
47
47
 
48
48
 
func keyAssetPoolsNumber (assetId) = makeString(["%s%s", "pools", assetId], SEP)
49
49
 
50
50
 
51
51
 
func keyTickerToAssetId (ticker) = makeString(["%s%s", "ticker2assetId", ticker], SEP)
52
52
 
53
53
 
54
54
 
func keyAssetIdToTicker (assetId) = makeString(["%s%s", "assetId2ticker", assetId], SEP)
55
55
 
56
56
 
57
57
 
func keyAmountAndPriceAssetsToLpAsset (amountAsset,priceAsset) = makeString(["%s%s%s", "amountAndPriceAssetsToLpAsset", amountAsset, priceAsset], SEP)
58
58
 
59
59
 
60
60
 
func keyLpAssetToAmountAndPriceAssets (lpAsset) = makeString(["%s%s", "lpAssetToAmountAndPriceAssets", lpAsset], SEP)
61
61
 
62
62
 
63
63
 
func keyAssetLabels (assetId) = makeString(["%s%s", "labels", assetId], SEP)
64
64
 
65
65
 
66
66
 
func keyLabels () = makeString(["%s", "labels"], SEP)
67
67
 
68
68
 
69
69
 
func keyAssetName (assetId) = makeString(["%s%s", "assetName", assetId], SEP)
70
70
 
71
71
 
72
72
 
func keyManagerVaultAddress () = "%s__managerVaultAddress"
73
73
 
74
74
 
75
75
 
func keyManagerPublicKey () = "%s__managerPublicKey"
76
76
 
77
77
 
78
78
 
func keyAssetDescription (assetId) = makeString(["%s%s", "assetDescription", assetId], SEP)
79
+
80
+
81
+
func keyMemePoolFactory () = makeString(["%s", "memePoolFactory"], SEP)
79
82
 
80
83
 
81
84
 
func getValueOrFail (address,key,type) = {
82
85
 
    let error = makeString(["mandatory ", toString(address), ".", key, " is not defined"], "")
83
86
 
    valueOrErrorMessage(    match type {
84
87
 
        case str: String => 
85
88
 
            getString(address, key)
86
89
 
        case int: Int => 
87
90
 
            getInteger(address, key)
88
91
 
        case _ => 
89
92
 
            throw("invalid entry type")
90
93
 
    }, error)
91
94
 
    }
92
95
 
93
96
 
94
97
 
func getStrOrFail (address,key) = {
95
98
 
    let @ = getValueOrFail(address, key, "")
96
99
 
    if ($isInstanceOf(@, "String"))
97
100
 
        then @
98
101
 
        else throw("Couldn't cast Int|String to String")
99
102
 
    }
100
103
 
101
104
 
102
105
 
func getIntOrFail (address,key) = {
103
106
 
    let @ = getValueOrFail(address, key, 0)
104
107
 
    if ($isInstanceOf(@, "Int"))
105
108
 
        then @
106
109
 
        else throw("Couldn't cast Int|String to Int")
107
110
 
    }
108
111
 
109
112
 
110
113
 
func isVerified (assetId) = (valueOrElse(getInteger(keyStatus(assetId)), statusUnverified) == statusVerified)
111
114
 
112
115
 
113
116
 
func getLabels () = match getString(keyLabels()) {
114
117
 
    case s: String => 
115
118
 
        if ((size(s) == 0))
116
119
 
            then nil
117
120
 
            else split(s, SEP)
118
121
 
    case _ => 
119
122
 
        nil
120
123
 
}
121
124
 
122
125
 
123
126
 
func getAssetLabels (assetId) = match getString(keyAssetLabels(assetId)) {
124
127
 
    case s: String => 
125
128
 
        if ((size(s) == 0))
126
129
 
            then nil
127
130
 
            else split(s, SEP)
128
131
 
    case _ => 
129
132
 
        nil
130
133
 
}
131
134
 
132
135
 
133
136
 
func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
134
137
 
    case s: String => 
135
138
 
        addressFromStringValue(s)
136
139
 
    case _ => 
137
140
 
        this
138
141
 
}
139
142
 
140
143
 
141
144
 
func managerPublicKeyOrUnit () = {
142
145
 
    let managerVaultAddress = getManagerVaultAddressOrThis()
143
146
 
    match getString(managerVaultAddress, keyManagerPublicKey()) {
144
147
 
        case s: String => 
145
148
 
            fromBase58String(s)
146
149
 
        case _: Unit => 
147
150
 
            unit
148
151
 
        case _ => 
149
152
 
            throw("Match error")
150
153
 
    }
151
154
 
    }
152
155
 
153
156
 
154
157
 
func isManager (i) = match managerPublicKeyOrUnit() {
155
158
 
    case pk: ByteVector => 
156
159
 
        (i.callerPublicKey == pk)
157
160
 
    case _: Unit => 
158
161
 
        (i.caller == this)
159
162
 
    case _ => 
160
163
 
        throw("Match error")
161
164
 
}
162
165
 
163
166
 
164
167
 
func mustManager (i) = if (isManager(i))
165
168
 
    then true
166
169
 
    else throw("permission denied")
167
170
 
168
171
 
169
172
 
func mustAdmin (i) = {
170
173
 
    let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
171
174
 
    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
172
175
 
        then true
173
176
 
        else mustManager(i)
174
177
 
    }
175
178
 
176
179
 
177
180
 
func isCreated (assetId) = valueOrElse(getBoolean(keyCreated(assetId)), false)
181
+
182
+
183
+
func isMemePoolFactory (i) = match getString(this, keyFactoryContract()) {
184
+
    case factoryAddress: String => 
185
+
        match addressFromString(factoryAddress) {
186
+
            case factoryContract: Address => 
187
+
                match getString(factoryContract, keyMemePoolFactory()) {
188
+
                    case memePoolFactoryAddress: String => 
189
+
                        (toString(i.caller) == memePoolFactoryAddress)
190
+
                    case _ => 
191
+
                        false
192
+
                }
193
+
            case _ => 
194
+
                false
195
+
        }
196
+
    case _ => 
197
+
        false
198
+
}
178
199
 
179
200
 
180
201
 
func verifiedToStatus (verified) = if (verified)
181
202
 
    then statusVerified
182
203
 
    else statusUnverified
183
204
 
184
205
 
185
206
 
func addLabelActions (assetId,label,throwOnError) = {
186
207
 
    let labels = getLabels()
187
208
 
    let assetLabels = getAssetLabels(assetId)
188
209
 
    let checkLabel = if (containsElement(labels, label))
189
210
 
        then true
190
211
 
        else throw("Label doesn't exist")
191
212
 
    if ((checkLabel == checkLabel))
192
213
 
        then {
193
214
 
            let newAssetLabels = if (containsElement(assetLabels, label))
194
215
 
                then if (throwOnError)
195
216
 
                    then throw("Label has already been added")
196
217
 
                    else assetLabels
197
218
 
                else (assetLabels :+ label)
198
219
 
[StringEntry(keyAssetLabels(assetId), makeString(newAssetLabels, SEP))]
199
220
 
            }
200
221
 
        else throw("Strict value is not equal to itself.")
201
222
 
    }
202
223
 
203
224
 
204
225
 
func deleteLabelActions (assetId,label,throwOnError) = {
205
226
 
    let assetLabels = getAssetLabels(assetId)
206
227
 
    let newAssetLabels = if (containsElement(assetLabels, label))
207
228
 
        then removeByIndex(assetLabels, value(indexOf(assetLabels, label)))
208
229
 
        else if (throwOnError)
209
230
 
            then throw("Label wasn't added")
210
231
 
            else assetLabels
211
232
 
[StringEntry(keyAssetLabels(assetId), makeString(newAssetLabels, SEP))]
212
233
 
    }
213
234
 
214
235
 
215
236
 
func setVerifiedActions (assetId,verified) = {
216
237
 
    let labelCommunityVerifiedActions = if (verified)
217
238
 
        then addLabelActions(assetId, labelCommunityVerified, false)
218
239
 
        else deleteLabelActions(assetId, labelCommunityVerified, false)
219
240
 
    ([IntegerEntry(keyStatus(assetId), verifiedToStatus(verified))] ++ labelCommunityVerifiedActions)
220
241
 
    }
221
242
 
222
243
 
223
244
 
@Callable(i)
224
245
 
func setAssetName (assetID,assetName) = {
225
246
 
    let checkCaller = mustAdmin(i)
226
247
 
    if ((checkCaller == checkCaller))
227
248
 
        then [StringEntry(keyAssetName(assetID), assetName)]
228
249
 
        else throw("Strict value is not equal to itself.")
229
250
 
    }
230
251
 
231
252
 
232
253
 
233
254
 
@Callable(i)
234
255
 
func setAssetDescription (assetID,assetDescription) = {
235
256
 
    let checkCaller = mustAdmin(i)
236
257
 
    if ((checkCaller == checkCaller))
237
258
 
        then [StringEntry(keyAssetDescription(assetID), assetDescription)]
238
259
 
        else throw("Strict value is not equal to itself.")
239
260
 
    }
240
261
 
241
262
 
242
263
 
243
264
 
@Callable(i)
244
265
 
func constructor (userPoolsContract,labels) = {
245
266
 
    let checkCaller = mustManager(i)
246
267
 
    if ((checkCaller == checkCaller))
247
268
 
        then {
248
269
 
            let checksAddress = valueOrErrorMessage(addressFromString(userPoolsContract), "Invalid address")
249
270
 
            if ((checksAddress == checksAddress))
250
271
 
                then [StringEntry(keyUserPoolsContract(), userPoolsContract), StringEntry(keyLabels(), makeString((defaultLabels ++ labels), SEP))]
251
272
 
                else throw("Strict value is not equal to itself.")
252
273
 
            }
253
274
 
        else throw("Strict value is not equal to itself.")
254
275
 
    }
255
276
 
256
277
 
257
278
 
258
279
 
@Callable(i)
259
280
 
func constructorV2 (factoryContract) = {
260
281
 
    let checkCaller = mustManager(i)
261
282
 
    if ((checkCaller == checkCaller))
262
283
 
        then {
263
284
 
            let checkAddress = valueOrErrorMessage(addressFromString(factoryContract), "invalid factory contract address")
264
285
 
            if ((checkAddress == checkAddress))
265
286
 
                then [StringEntry(keyFactoryContract(), factoryContract)]
266
287
 
                else throw("Strict value is not equal to itself.")
267
288
 
            }
268
289
 
        else throw("Strict value is not equal to itself.")
269
290
 
    }
270
291
 
271
292
 
272
293
 
273
294
 
@Callable(i)
274
295
 
func addAssetsLink (amountAsset,priceAsset,lpAsset) = {
275
296
 
    let checkCaller = mustAdmin(i)
276
297
 
    if ((checkCaller == checkCaller))
277
298
 
        then [StringEntry(keyAmountAndPriceAssetsToLpAsset(amountAsset, priceAsset), lpAsset), StringEntry(keyLpAssetToAmountAndPriceAssets(lpAsset), makeString([amountAsset, priceAsset], SEP))]
278
299
 
        else throw("Strict value is not equal to itself.")
279
300
 
    }
280
301
 
281
302
 
282
303
 
283
304
 
@Callable(i)
284
305
 
func increaseAssetPoolsNumber (assetId) = {
285
306
 
    let checkCaller = mustAdmin(i)
286
307
 
    if ((checkCaller == checkCaller))
287
308
 
        then {
288
309
 
            let assetPoolsNumberKey = keyAssetPoolsNumber(assetId)
289
310
 
            let assetPoolsNumber = valueOrElse(getInteger(assetPoolsNumberKey), 0)
290
311
 
[IntegerEntry(assetPoolsNumberKey, (assetPoolsNumber + 1))]
291
312
 
            }
292
313
 
        else throw("Strict value is not equal to itself.")
293
314
 
    }
294
315
 
295
316
 
296
317
 
297
318
 
@Callable(i)
298
319
 
func createLabel (label) = {
299
320
 
    let labels = getLabels()
300
321
 
    let checkCaller = mustAdmin(i)
301
322
 
    if ((checkCaller == checkCaller))
302
323
 
        then {
303
324
 
            let checkLabel = [if (!(contains(label, SEP)))
304
325
 
                then true
305
326
 
                else throw("Invalid label name"), if (!(containsElement(labels, label)))
306
327
 
                then true
307
328
 
                else throw("Label exists")]
308
329
 
            if ((checkLabel == checkLabel))
309
330
 
                then [StringEntry(keyLabels(), makeString((labels :+ label), SEP))]
310
331
 
                else throw("Strict value is not equal to itself.")
311
332
 
            }
312
333
 
        else throw("Strict value is not equal to itself.")
313
334
 
    }
314
335
 
315
336
 
316
337
 
317
338
 
@Callable(i)
318
339
 
func dropLabel (label) = {
319
340
 
    let labels = getLabels()
320
341
 
    let checkCaller = mustManager(i)
321
342
 
    if ((checkCaller == checkCaller))
322
343
 
        then {
323
344
 
            let checkLabel = if (containsElement(labels, label))
324
345
 
                then true
325
346
 
                else throw("Label doesn't exist")
326
347
 
            if ((checkLabel == checkLabel))
327
348
 
                then [StringEntry(keyLabels(), makeString(removeByIndex(labels, value(indexOf(labels, label))), SEP))]
328
349
 
                else throw("Strict value is not equal to itself.")
329
350
 
            }
330
351
 
        else throw("Strict value is not equal to itself.")
331
352
 
    }
332
353
 
333
354
 
334
355
 
335
356
 
@Callable(i)
336
357
 
func addLabel (assetId,label) = {
337
358
 
    let checkCaller = mustAdmin(i)
338
359
 
    if ((checkCaller == checkCaller))
339
360
 
        then addLabelActions(assetId, label, true)
340
361
 
        else throw("Strict value is not equal to itself.")
341
362
 
    }
342
363
 
343
364
 
344
365
 
345
366
 
@Callable(i)
346
367
 
func deleteLabel (assetId,label) = {
347
368
 
    let checkCaller = mustAdmin(i)
348
369
 
    if ((checkCaller == checkCaller))
349
370
 
        then deleteLabelActions(assetId, label, true)
350
371
 
        else throw("Strict value is not equal to itself.")
351
372
 
    }
352
373
 
353
374
 
354
375
 
355
376
 
@Callable(i)
356
377
 
func updateTicker (assetId,ticker) = {
357
378
 
    let checkCaller = mustAdmin(i)
358
379
 
    if ((checkCaller == checkCaller))
359
380
 
        then {
360
381
 
            let checkAsset = if (isCreated(assetId))
361
382
 
                then true
362
383
 
                else throwNoAsset()
363
384
 
            if ((checkAsset == checkAsset))
364
385
 
                then {
365
386
 
                    let checkTicker = if ((ticker != ""))
366
387
 
                        then true
367
388
 
                        else throwInvalidTicker()
368
389
 
                    if ((checkTicker == checkTicker))
369
390
 
                        then {
370
391
 
                            let deleteActions = (                            match getString(keyTickerToAssetId(ticker)) {
371
392
 
                                case assetIdOld: String => 
372
393
 
[DeleteEntry(keyAssetIdToTicker(assetIdOld))]
373
394
 
                                case _: Unit => 
374
395
 
                                    nil
375
396
 
                                case _ => 
376
397
 
                                    throw("Match error")
377
398
 
                            } ++                             match getString(keyAssetIdToTicker(assetId)) {
378
399
 
                                case tickerOld: String => 
379
400
 
[DeleteEntry(keyTickerToAssetId(tickerOld))]
380
401
 
                                case _: Unit => 
381
402
 
                                    nil
382
403
 
                                case _ => 
383
404
 
                                    throw("Match error")
384
405
 
                            })
385
406
 
                            let updateActions = [StringEntry(keyAssetIdToTicker(assetId), ticker), StringEntry(keyTickerToAssetId(ticker), assetId)]
386
407
 
                            (deleteActions ++ updateActions)
387
408
 
                            }
388
409
 
                        else throw("Strict value is not equal to itself.")
389
410
 
                    }
390
411
 
                else throw("Strict value is not equal to itself.")
391
412
 
            }
392
413
 
        else throw("Strict value is not equal to itself.")
393
414
 
    }
394
415
 
395
416
 
396
417
 
397
418
 
@Callable(i)
398
419
 
func deleteTicker (assetId) = {
399
420
 
    let checkCaller = mustAdmin(i)
400
421
 
    if ((checkCaller == checkCaller))
401
422
 
        then {
402
423
 
            let ticker = valueOrErrorMessage(getString(keyAssetIdToTicker(assetId)), "Invalid asset")
403
424
 
[DeleteEntry(keyAssetIdToTicker(assetId)), DeleteEntry(keyTickerToAssetId(ticker))]
404
425
 
            }
405
426
 
        else throw("Strict value is not equal to itself.")
406
427
 
    }
407
428
 
408
429
 
409
430
 
410
431
 
@Callable(i)
411
432
 
func createOrUpdate (assetId,logo,verified) = {
412
-
    let checkCaller = mustAdmin(i)
433
+
    let checkCaller = if (isMemePoolFactory(i))
434
+
        then true
435
+
        else mustAdmin(i)
413
436
 
    if ((checkCaller == checkCaller))
414
437
 
        then {
415
438
 
            let isCreatedNow = !(isCreated(assetId))
416
439
 
            if ((isCreatedNow == isCreatedNow))
417
440
 
                then {
418
441
 
                    let setLogoActions = if ((logo == ""))
419
442
 
                        then nil
420
443
 
                        else [StringEntry(keyLogo(assetId), logo)]
421
444
 
                    $Tuple2((([BooleanEntry(keyCreated(assetId), true)] ++ setLogoActions) ++ setVerifiedActions(assetId, verified)), isCreatedNow)
422
445
 
                    }
423
446
 
                else throw("Strict value is not equal to itself.")
424
447
 
            }
425
448
 
        else throw("Strict value is not equal to itself.")
426
449
 
    }
427
450
 
428
451
 
429
452
 
430
453
 
@Callable(i)
431
454
 
func setLogo (assetId,logo) = {
432
455
 
    let checks = [mustAdmin(i), if (isCreated(assetId))
433
456
 
        then true
434
457
 
        else throwNoAsset()]
435
458
 
    if ((checks == checks))
436
459
 
        then {
437
460
 
            let action = if ((logo == ""))
438
461
 
                then DeleteEntry(keyLogo(assetId))
439
462
 
                else StringEntry(keyLogo(assetId), logo)
440
463
 
[action]
441
464
 
            }
442
465
 
        else throw("Strict value is not equal to itself.")
443
466
 
    }
444
467
 
445
468
 
446
469
 
447
470
 
@Callable(i)
448
471
 
func getAssetLogoREADONLY (assetId) = {
449
472
 
    let logo = valueOrElse(getString(keyLogo(assetId)), "")
450
473
 
    $Tuple2(nil, logo)
451
474
 
    }
452
475
 
453
476
 
454
477
 
455
478
 
@Callable(i)
456
479
 
func setVerified (assetId,verified) = {
457
480
 
    let checks = [mustAdmin(i), if (isCreated(assetId))
458
481
 
        then true
459
482
 
        else throwNoAsset()]
460
483
 
    if ((checks == checks))
461
484
 
        then {
462
485
 
            let onVerificationLossInv = if (!(verified))
463
486
 
                then {
464
487
 
                    let factoryContract = valueOrErrorMessage(addressFromString(getStrOrFail(this, keyFactoryContract())), "invalid factory contract address")
465
488
 
                    invoke(factoryContract, "onVerificationLoss", [assetId], nil)
466
489
 
                    }
467
490
 
                else unit
468
491
 
            if ((onVerificationLossInv == onVerificationLossInv))
469
492
 
                then $Tuple2(setVerifiedActions(assetId, verified), unit)
470
493
 
                else throw("Strict value is not equal to itself.")
471
494
 
            }
472
495
 
        else throw("Strict value is not equal to itself.")
473
496
 
    }
474
497
 
475
498
 
476
499
 
477
500
 
@Callable(i)
478
501
 
func onEliminate (assetId) = {
479
502
 
    let poolsNumber = valueOrElse(getInteger(keyAssetPoolsNumber(assetId)), 0)
480
503
 
    let actions = if ((poolsNumber > 0))
481
504
 
        then nil
482
505
 
        else [DeleteEntry(keyLogo(assetId))]
483
506
 
    $Tuple2(actions, unit)
484
507
 
    }
485
508
 
486
509
 
487
510
 
488
511
 
@Callable(i)
489
512
 
func setAdmins (adminPubKeys) = {
490
513
 
    let checkCaller = mustManager(i)
491
514
 
    if ((checkCaller == checkCaller))
492
515
 
        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
493
516
 
        else throw("Strict value is not equal to itself.")
494
517
 
    }
495
518
 
496
519
 
497
520
 
498
521
 
@Callable(i)
499
522
 
func isVerifiedREADONLY (assetId) = $Tuple2(nil, isVerified(assetId))
500
523
 
501
524
 
502
525
 
503
526
 
@Callable(i)
504
527
 
func deletePool (amountAssetId,priceAssetId) = {
505
528
 
    let factoryContract = addressFromStringValue(getStringValue(keyFactoryContract()))
506
529
 
    let checkCaller = if ((i.caller == factoryContract))
507
530
 
        then true
508
531
 
        else mustManager(i)
509
532
 
    if ((checkCaller == checkCaller))
510
533
 
        then {
511
534
 
            let lpAssetId = valueOrElse(getString(keyAmountAndPriceAssetsToLpAsset(amountAssetId, priceAssetId)), "")
512
535
 
            let poolKeysDeleteActions = if ((lpAssetId == ""))
513
536
 
                then nil
514
537
 
                else [DeleteEntry(keyLpAssetToAmountAndPriceAssets(lpAssetId)), DeleteEntry(keyAssetLabels(lpAssetId)), DeleteEntry(keyAssetName(lpAssetId)), DeleteEntry(keyAssetDescription(lpAssetId)), DeleteEntry(keyCreated(lpAssetId)), DeleteEntry(keyStatus(lpAssetId)), DeleteEntry(keyLogo(lpAssetId)), DeleteEntry(keyTicker(lpAssetId)), DeleteEntry(keyAmountAndPriceAssetsToLpAsset(amountAssetId, priceAssetId))]
515
538
 
            poolKeysDeleteActions
516
539
 
            }
517
540
 
        else throw("Strict value is not equal to itself.")
518
541
 
    }
519
542
 
520
543
 
521
544
 
@Verifier(tx)
522
545
 
func verify () = {
523
546
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
524
547
 
        case pk: ByteVector => 
525
548
 
            pk
526
549
 
        case _: Unit => 
527
550
 
            tx.senderPublicKey
528
551
 
        case _ => 
529
552
 
            throw("Match error")
530
553
 
    }
531
554
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
532
555
 
    }
533
556
 

github/deemru/w8io/169f3d6 
54.58 ms ◑