tx · ETUBV2M8wdf1jrfCn8JiWNSinYapDMBAqCox5B8hYzNS

3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh:  -0.01800000 Waves

2022.05.25 13:40 [2067107] smart account 3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "ETUBV2M8wdf1jrfCn8JiWNSinYapDMBAqCox5B8hYzNS",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1653475202369,
    "version": 1,
    "sender": "3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh",
    "senderPublicKey": "Ap7CkWd6fzBU34kGo4GJJzC5q4qWXuLVunzE25PchdGS",
    "proofs": [
        "3BXWiVkuqRrJaFQ6GDxjmf1Av43CHijWJWqfL9f3Tw48VReMNskvKqseospRxAYhWDoKm6qTgiaxmQCGum195Hav"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2067107,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6P2Atkec7xw9zwuMRC21HJuWQktijo9pVDxR9fVY66f3
Next: 8FR533YiSajVwX3MYfK5V8KYJF9QrBBSAjNTNETbVA2y

Diff: 
Old
New
Differences
49
49
 
func keyAdminPubKeys () = makeString(["%s", "adminPubKeys"], SEP)
50
50
 
51
51
 
52
+
func keyStatus (amountAssetId,priceAssetId) = makeString(["%s%s%s", "status", amountAssetId, priceAssetId], SEP)
53
+
54
+
52
55
 
func keyFactoryContract () = makeString(["%s", "factoryContract"], SEP)
53
56
 
54
57
 
55
58
 
func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], SEP)
56
59
 
57
60
 
58
-
func keyStatus (amountAssetId,priceAssetId) = makeString(["%s%s%s", "status", amountAssetId, priceAssetId], SEP)
61
+
func keySuffix (amountAssetId,priceAssetId) = makeString(["%s%s%s", "suffix", amountAssetId, priceAssetId], SEP)
59
62
 
63
+
64
+
func keyLastIndex () = makeString(["%s", "lastIndex"], SEP)
65
+
66
+
67
+
let indexSuffix = "u"
60
68
 
61
69
 
let statusPending = "pending"
62
70
 
181
189
 
    let amountAssetPayment = value(i.payments[0])
182
190
 
    let priceAssetPayment = value(i.payments[1])
183
191
 
    let feeAssetPayment = value(i.payments[2])
184
-
    let $t057695840 = getIdAndInfo(amountAssetPayment)
185
-
    let amountAssetId = $t057695840._1
186
-
    let amountAssetInfo = $t057695840._2
187
-
    let $t058435911 = getIdAndInfo(priceAssetPayment)
188
-
    let priceAssetId = $t058435911._1
189
-
    let priceAssetInfo = $t058435911._2
190
-
    let $t059145976 = getIdAndInfo(feeAssetPayment)
191
-
    let feeAssetId = $t059145976._1
192
-
    let feeAssetInfo = $t059145976._2
192
+
    let $t059786049 = getIdAndInfo(amountAssetPayment)
193
+
    let amountAssetId = $t059786049._1
194
+
    let amountAssetInfo = $t059786049._2
195
+
    let $t060526120 = getIdAndInfo(priceAssetPayment)
196
+
    let priceAssetId = $t060526120._1
197
+
    let priceAssetInfo = $t060526120._2
198
+
    let $t061236185 = getIdAndInfo(feeAssetPayment)
199
+
    let feeAssetId = $t061236185._1
200
+
    let feeAssetInfo = $t061236185._2
193
201
 
    let priceAssetsList = split(valueOrElse(getString(keyPriceAssetIds()), EMPTY), SEP)
194
202
 
    let priceAssetsIndex = valueOrErrorMessage(indexOf(priceAssetsList, priceAssetId), invalidPriceAsset)
203
+
    let lastIndex = valueOrElse(getInteger(keyLastIndex()), 0)
204
+
    let curIndex = (lastIndex + 1)
195
205
 
    let checks = [if (!(isCreateCalled(amountAssetId, priceAssetId)))
196
206
 
        then true
197
207
 
        else throwPoolExists(), if ((amountAssetInfo.issuer == i.caller))
208
218
 
        then true
209
219
 
        else throw()]
210
220
 
    if ((checks == checks))
211
-
        then [BooleanEntry(keyCreateCalled(amountAssetId, priceAssetId), true), IntegerEntry(keyHeight(amountAssetId, priceAssetId), height), StringEntry(keyStatus(amountAssetId, priceAssetId), statusPending), IntegerEntry(keyAmountAssetAmount(amountAssetId, priceAssetId), amountAssetPayment.amount), IntegerEntry(keyPriceAssetAmount(amountAssetId, priceAssetId), priceAssetPayment.amount)]
221
+
        then [BooleanEntry(keyCreateCalled(amountAssetId, priceAssetId), true), IntegerEntry(keyLastIndex(), curIndex), StringEntry(keySuffix(amountAssetId, priceAssetId), (toString(curIndex) + indexSuffix)), IntegerEntry(keyHeight(amountAssetId, priceAssetId), height), StringEntry(keyStatus(amountAssetId, priceAssetId), statusPending), IntegerEntry(keyAmountAssetAmount(amountAssetId, priceAssetId), amountAssetPayment.amount), IntegerEntry(keyPriceAssetAmount(amountAssetId, priceAssetId), priceAssetPayment.amount)]
212
222
 
        else throw("Strict value is not equal to itself.")
213
223
 
    }
214
224
 

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 invalidPriceAsset = "Invalid price asset"
9
9
 
10
10
 
func throwPD () = throw("Permission denied")
11
11
 
12
12
 
13
13
 
func throwCreateNotCalled () = throw("Create is not called for assets pair")
14
14
 
15
15
 
16
16
 
func throwYouNotIssuer () = throw("You are not amountAsset issuer")
17
17
 
18
18
 
19
19
 
func throwPoolExists () = throw("Pool with such assets already exists")
20
20
 
21
21
 
22
22
 
func throwAssetNotVerified () = throw("Asset is not verified")
23
23
 
24
24
 
25
25
 
func throwInvalidPriceAsset () = throw(invalidPriceAsset)
26
26
 
27
27
 
28
28
 
func throwInvalidFeeAsset () = throw("Invalid fee asset")
29
29
 
30
30
 
31
31
 
func throwInvalidAmountAsset () = throw("Invalid amount asset attached")
32
32
 
33
33
 
34
34
 
func throwInvalidStatus () = throw("Invalid status")
35
35
 
36
36
 
37
37
 
func throwCanActivateOnlyPendingPool () = throw("Can activate pool only in 'pending' status")
38
38
 
39
39
 
40
40
 
func throwFactoryReturnedNotString () = throw("FactoryV2 returned not string")
41
41
 
42
42
 
43
43
 
func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
44
44
 
45
45
 
46
46
 
func keyPendingManagerPublicKey () = makeString(["%s", "pendingManagerPublicKey"], SEP)
47
47
 
48
48
 
49
49
 
func keyAdminPubKeys () = makeString(["%s", "adminPubKeys"], SEP)
50
50
 
51
51
 
52
+
func keyStatus (amountAssetId,priceAssetId) = makeString(["%s%s%s", "status", amountAssetId, priceAssetId], SEP)
53
+
54
+
52
55
 
func keyFactoryContract () = makeString(["%s", "factoryContract"], SEP)
53
56
 
54
57
 
55
58
 
func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], SEP)
56
59
 
57
60
 
58
-
func keyStatus (amountAssetId,priceAssetId) = makeString(["%s%s%s", "status", amountAssetId, priceAssetId], SEP)
61
+
func keySuffix (amountAssetId,priceAssetId) = makeString(["%s%s%s", "suffix", amountAssetId, priceAssetId], SEP)
59
62
 
63
+
64
+
func keyLastIndex () = makeString(["%s", "lastIndex"], SEP)
65
+
66
+
67
+
let indexSuffix = "u"
60
68
 
61
69
 
let statusPending = "pending"
62
70
 
63
71
 
let statusDeclined = "declined"
64
72
 
65
73
 
let statusActive = "active"
66
74
 
67
75
 
let statuses = [statusPending, statusDeclined, statusActive]
68
76
 
69
77
 
func keyCreateCalled (amountAssetId,priceAssetId) = makeString(["%s%s%s", "createCalled", amountAssetId, priceAssetId], SEP)
70
78
 
71
79
 
72
80
 
func keyAmountAssetAmount (amountAssetId,priceAssetId) = makeString(["%s%s%s", "amountAssetAmount", amountAssetId, priceAssetId], SEP)
73
81
 
74
82
 
75
83
 
func keyPriceAssetAmount (amountAssetId,priceAssetId) = makeString(["%s%s%s", "priceAssetAmount", amountAssetId, priceAssetId], SEP)
76
84
 
77
85
 
78
86
 
func keyHeight (amountAssetId,priceAssetId) = makeString(["%s%s%s", "height", amountAssetId, priceAssetId], SEP)
79
87
 
80
88
 
81
89
 
func keyFeeAssetId () = makeString(["%s", "feeAssetId"], SEP)
82
90
 
83
91
 
84
92
 
func keyFeeAmount () = makeString(["%s", "feeAmount"], SEP)
85
93
 
86
94
 
87
95
 
func keyAmountAssetMinAmount () = makeString(["%s", "amountAssetMinAmount"], SEP)
88
96
 
89
97
 
90
98
 
func keyPriceAssetsMinAmount () = makeString(["%s", "priceAssetsMinAmount"], SEP)
91
99
 
92
100
 
93
101
 
func keyPriceAssetIds () = makeString(["%s", "priceAssetIds"], SEP)
94
102
 
95
103
 
96
104
 
func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), (key + " is not defined"))
97
105
 
98
106
 
99
107
 
let factoryContract = addressFromStringValue(getStringOrFail(keyFactoryContract()))
100
108
 
101
109
 
func isCreateCalled (amountAssetId,priceAssetId) = valueOrElse(getBoolean(keyCreateCalled(amountAssetId, priceAssetId)), false)
102
110
 
103
111
 
104
112
 
func mustCreateCalled (amountAssetId,priceAssetId) = if (isCreateCalled(amountAssetId, priceAssetId))
105
113
 
    then true
106
114
 
    else throwCreateNotCalled()
107
115
 
108
116
 
109
117
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
110
118
 
    case s: String => 
111
119
 
        fromBase58String(s)
112
120
 
    case _: Unit => 
113
121
 
        unit
114
122
 
    case _ => 
115
123
 
        throw("Match error")
116
124
 
}
117
125
 
118
126
 
119
127
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
120
128
 
    case s: String => 
121
129
 
        fromBase58String(s)
122
130
 
    case _: Unit => 
123
131
 
        unit
124
132
 
    case _ => 
125
133
 
        throw("Match error")
126
134
 
}
127
135
 
128
136
 
129
137
 
func mustManager (i) = match managerPublicKeyOrUnit() {
130
138
 
    case pk: ByteVector => 
131
139
 
        if ((i.callerPublicKey == pk))
132
140
 
            then true
133
141
 
            else throwPD()
134
142
 
    case _: Unit => 
135
143
 
        if ((i.caller == this))
136
144
 
            then true
137
145
 
            else throwPD()
138
146
 
    case _ => 
139
147
 
        throw("Match error")
140
148
 
}
141
149
 
142
150
 
143
151
 
func mustAdmin (i) = {
144
152
 
    let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
145
153
 
    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
146
154
 
        then true
147
155
 
        else {
148
156
 
            let isManager = mustManager(i)
149
157
 
            if ((isManager == isManager))
150
158
 
                then true
151
159
 
                else throw("Strict value is not equal to itself.")
152
160
 
            }
153
161
 
    }
154
162
 
155
163
 
156
164
 
func isVerified (assetId) = (valueOrElse(getInteger(addressFromStringValue(getStringOrFail(keyAssetsStoreContract())), (("status_<" + assetId) + ">")), 0) == 2)
157
165
 
158
166
 
159
167
 
func getIdAndInfo (payment) = {
160
168
 
    let id = value(payment.assetId)
161
169
 
    let info = value(assetInfo(id))
162
170
 
    $Tuple2(toBase58String(id), info)
163
171
 
    }
164
172
 
165
173
 
166
174
 
func validStatus (status) = containsElement(statuses, status)
167
175
 
168
176
 
169
177
 
@Callable(i)
170
178
 
func constructor (factoryV2Address,assetsStoreAddress,priceAssetIds,priceAssetsMinAmount,amountAssetMinAmount,feeAssetId,feeAmount) = {
171
179
 
    let checkCaller = mustManager(i)
172
180
 
    if ((checkCaller == checkCaller))
173
181
 
        then [StringEntry(keyFactoryContract(), factoryV2Address), StringEntry(keyAssetsStoreContract(), assetsStoreAddress), StringEntry(keyPriceAssetIds(), makeString(priceAssetIds, SEP)), StringEntry(keyPriceAssetsMinAmount(), makeString(priceAssetsMinAmount, SEP)), IntegerEntry(keyAmountAssetMinAmount(), amountAssetMinAmount), StringEntry(keyFeeAssetId(), feeAssetId), IntegerEntry(keyFeeAmount(), feeAmount)]
174
182
 
        else throw("Strict value is not equal to itself.")
175
183
 
    }
176
184
 
177
185
 
178
186
 
179
187
 
@Callable(i)
180
188
 
func create () = {
181
189
 
    let amountAssetPayment = value(i.payments[0])
182
190
 
    let priceAssetPayment = value(i.payments[1])
183
191
 
    let feeAssetPayment = value(i.payments[2])
184
-
    let $t057695840 = getIdAndInfo(amountAssetPayment)
185
-
    let amountAssetId = $t057695840._1
186
-
    let amountAssetInfo = $t057695840._2
187
-
    let $t058435911 = getIdAndInfo(priceAssetPayment)
188
-
    let priceAssetId = $t058435911._1
189
-
    let priceAssetInfo = $t058435911._2
190
-
    let $t059145976 = getIdAndInfo(feeAssetPayment)
191
-
    let feeAssetId = $t059145976._1
192
-
    let feeAssetInfo = $t059145976._2
192
+
    let $t059786049 = getIdAndInfo(amountAssetPayment)
193
+
    let amountAssetId = $t059786049._1
194
+
    let amountAssetInfo = $t059786049._2
195
+
    let $t060526120 = getIdAndInfo(priceAssetPayment)
196
+
    let priceAssetId = $t060526120._1
197
+
    let priceAssetInfo = $t060526120._2
198
+
    let $t061236185 = getIdAndInfo(feeAssetPayment)
199
+
    let feeAssetId = $t061236185._1
200
+
    let feeAssetInfo = $t061236185._2
193
201
 
    let priceAssetsList = split(valueOrElse(getString(keyPriceAssetIds()), EMPTY), SEP)
194
202
 
    let priceAssetsIndex = valueOrErrorMessage(indexOf(priceAssetsList, priceAssetId), invalidPriceAsset)
203
+
    let lastIndex = valueOrElse(getInteger(keyLastIndex()), 0)
204
+
    let curIndex = (lastIndex + 1)
195
205
 
    let checks = [if (!(isCreateCalled(amountAssetId, priceAssetId)))
196
206
 
        then true
197
207
 
        else throwPoolExists(), if ((amountAssetInfo.issuer == i.caller))
198
208
 
        then true
199
209
 
        else throwYouNotIssuer(), if (isVerified(amountAssetId))
200
210
 
        then true
201
211
 
        else throwAssetNotVerified(), if ((getString(keyFeeAssetId()) == feeAssetId))
202
212
 
        then true
203
213
 
        else throwInvalidFeeAsset(), if ((amountAssetPayment.amount >= getIntegerValue(keyAmountAssetMinAmount())))
204
214
 
        then true
205
215
 
        else throwInvalidAmountAsset(), if ((priceAssetPayment.amount >= value(parseInt(split(valueOrElse(getString(keyPriceAssetsMinAmount()), EMPTY), SEP)[priceAssetsIndex]))))
206
216
 
        then true
207
217
 
        else throw(), if ((feeAssetPayment.amount == getInteger(keyFeeAmount())))
208
218
 
        then true
209
219
 
        else throw()]
210
220
 
    if ((checks == checks))
211
-
        then [BooleanEntry(keyCreateCalled(amountAssetId, priceAssetId), true), IntegerEntry(keyHeight(amountAssetId, priceAssetId), height), StringEntry(keyStatus(amountAssetId, priceAssetId), statusPending), IntegerEntry(keyAmountAssetAmount(amountAssetId, priceAssetId), amountAssetPayment.amount), IntegerEntry(keyPriceAssetAmount(amountAssetId, priceAssetId), priceAssetPayment.amount)]
221
+
        then [BooleanEntry(keyCreateCalled(amountAssetId, priceAssetId), true), IntegerEntry(keyLastIndex(), curIndex), StringEntry(keySuffix(amountAssetId, priceAssetId), (toString(curIndex) + indexSuffix)), IntegerEntry(keyHeight(amountAssetId, priceAssetId), height), StringEntry(keyStatus(amountAssetId, priceAssetId), statusPending), IntegerEntry(keyAmountAssetAmount(amountAssetId, priceAssetId), amountAssetPayment.amount), IntegerEntry(keyPriceAssetAmount(amountAssetId, priceAssetId), priceAssetPayment.amount)]
212
222
 
        else throw("Strict value is not equal to itself.")
213
223
 
    }
214
224
 
215
225
 
216
226
 
217
227
 
@Callable(i)
218
228
 
func setStatus (amountAssetId,priceAssetId,newStatus) = {
219
229
 
    let checks = [mustAdmin(i), if (isCreateCalled(amountAssetId, priceAssetId))
220
230
 
        then true
221
231
 
        else throwCreateNotCalled(), if (validStatus(newStatus))
222
232
 
        then true
223
233
 
        else throwInvalidStatus()]
224
234
 
    if ((checks == checks))
225
235
 
        then [StringEntry(keyStatus(amountAssetId, priceAssetId), newStatus)]
226
236
 
        else throw("Strict value is not equal to itself.")
227
237
 
    }
228
238
 
229
239
 
230
240
 
231
241
 
@Callable(i)
232
242
 
func activate (poolAddress,amountAssetId,amountAssetTicker,priceAssetId,priceAssetTicker,logo) = {
233
243
 
    let checks = [mustManager(i), if (isCreateCalled(amountAssetId, priceAssetId))
234
244
 
        then true
235
245
 
        else throwCreateNotCalled(), if ((value(getString(keyStatus(amountAssetId, priceAssetId))) == statusPending))
236
246
 
        then true
237
247
 
        else throwCanActivateOnlyPendingPool()]
238
248
 
    if ((checks == checks))
239
249
 
        then {
240
250
 
            let activateNewPoolInv = invoke(factoryContract, "activateNewPool", [poolAddress, amountAssetId, priceAssetId, ((amountAssetTicker + priceAssetTicker) + "LP"), (((amountAssetTicker + "/") + priceAssetTicker) + " pool liquidity provider token"), 0, "VLTPOOL", logo], nil)
241
251
 
            if ((activateNewPoolInv == activateNewPoolInv))
242
252
 
                then {
243
253
 
                    let lpAssetId =                     match activateNewPoolInv {
244
254
 
                        case id: String => 
245
255
 
                            id
246
256
 
                        case _ => 
247
257
 
                            throwFactoryReturnedNotString()
248
258
 
                    }
249
259
 
                    if ((lpAssetId == lpAssetId))
250
260
 
                        then {
251
261
 
                            let beforePut = assetBalance(this, fromBase58String(lpAssetId))
252
262
 
                            if ((beforePut == beforePut))
253
263
 
                                then {
254
264
 
                                    let put = invoke(addressFromStringValue(poolAddress), "put", [0, false], [AttachedPayment(fromBase58String(amountAssetId), value(getInteger(keyAmountAssetAmount(amountAssetId, priceAssetId)))), AttachedPayment(fromBase58String(priceAssetId), value(getInteger(keyPriceAssetAmount(amountAssetId, priceAssetId))))])
255
265
 
                                    if ((put == put))
256
266
 
                                        then {
257
267
 
                                            let afterPut = assetBalance(this, fromBase58String(lpAssetId))
258
268
 
                                            if ((afterPut == afterPut))
259
269
 
                                                then {
260
270
 
                                                    let user = value(assetInfo(fromBase58String(amountAssetId))).issuer
261
271
 
[StringEntry(keyStatus(amountAssetId, priceAssetId), statusActive), ScriptTransfer(user, (afterPut - beforePut), fromBase58String(lpAssetId))]
262
272
 
                                                    }
263
273
 
                                                else throw("Strict value is not equal to itself.")
264
274
 
                                            }
265
275
 
                                        else throw("Strict value is not equal to itself.")
266
276
 
                                    }
267
277
 
                                else throw("Strict value is not equal to itself.")
268
278
 
                            }
269
279
 
                        else throw("Strict value is not equal to itself.")
270
280
 
                    }
271
281
 
                else throw("Strict value is not equal to itself.")
272
282
 
            }
273
283
 
        else throw("Strict value is not equal to itself.")
274
284
 
    }
275
285
 
276
286
 
277
287
 
278
288
 
@Callable(i)
279
289
 
func setAdmins (adminPubKeys) = {
280
290
 
    let checkCaller = mustManager(i)
281
291
 
    if ((checkCaller == checkCaller))
282
292
 
        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
283
293
 
        else throw("Strict value is not equal to itself.")
284
294
 
    }
285
295
 
286
296
 
287
297
 
288
298
 
@Callable(i)
289
299
 
func setManager (pendingManagerPublicKey) = {
290
300
 
    let checkCaller = mustManager(i)
291
301
 
    if ((checkCaller == checkCaller))
292
302
 
        then {
293
303
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
294
304
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
295
305
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
296
306
 
                else throw("Strict value is not equal to itself.")
297
307
 
            }
298
308
 
        else throw("Strict value is not equal to itself.")
299
309
 
    }
300
310
 
301
311
 
302
312
 
303
313
 
@Callable(i)
304
314
 
func confirmManager () = {
305
315
 
    let pm = pendingManagerPublicKeyOrUnit()
306
316
 
    let hasPM = if (isDefined(pm))
307
317
 
        then true
308
318
 
        else throw("No pending manager")
309
319
 
    if ((hasPM == hasPM))
310
320
 
        then {
311
321
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
312
322
 
                then true
313
323
 
                else throw("You are not pending manager")
314
324
 
            if ((checkPM == checkPM))
315
325
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
316
326
 
                else throw("Strict value is not equal to itself.")
317
327
 
            }
318
328
 
        else throw("Strict value is not equal to itself.")
319
329
 
    }
320
330
 
321
331
 
322
332
 
323
333
 
@Callable(i)
324
334
 
func priceAssetsREADONLY () = {
325
335
 
    let priceAssets =     match getString(keyPriceAssetIds()) {
326
336
 
        case s: String => 
327
337
 
            if ((size(s) == 0))
328
338
 
                then nil
329
339
 
                else split(s, SEP)
330
340
 
        case _ => 
331
341
 
            nil
332
342
 
    }
333
343
 
    $Tuple2(nil, priceAssets)
334
344
 
    }
335
345
 
336
346
 
337
347
 
338
348
 
@Callable(i)
339
349
 
func statusREADONLY (amountAssetId,priceAssetId) = {
340
350
 
    let status =     match getString(keyStatus(amountAssetId, priceAssetId)) {
341
351
 
        case s: String => 
342
352
 
            s
343
353
 
        case _ => 
344
354
 
            unit
345
355
 
    }
346
356
 
    $Tuple2(nil, status)
347
357
 
    }
348
358
 
349
359
 
350
360
 
@Verifier(tx)
351
361
 
func verify () = {
352
362
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
353
363
 
        case pk: ByteVector => 
354
364
 
            pk
355
365
 
        case _: Unit => 
356
366
 
            tx.senderPublicKey
357
367
 
        case _ => 
358
368
 
            throw("Match error")
359
369
 
    }
360
370
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
361
371
 
    }
362
372
 

github/deemru/w8io/3ef1775 
74.71 ms ◑