tx · 83dMzBzhGqG9tMz2gmpGm4HXYV2tvj3vzyVN6kNWyrpW

3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai:  -0.02200000 Waves

2023.02.09 15:48 [2442106] smart account 3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "83dMzBzhGqG9tMz2gmpGm4HXYV2tvj3vzyVN6kNWyrpW",
    "fee": 2200000,
    "feeAssetId": null,
    "timestamp": 1675946903215,
    "version": 1,
    "sender": "3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai",
    "senderPublicKey": "2JEaBjtjvMoNGKZmL9QxYefa1VkMJM3vMW8rNvTs9R2H",
    "proofs": [
        "25fqeUUfBHBTyoUZXFo8stEeK7USYmXc1uXJqTpSqLEtjbdFWvQpstK5wDxAiPLGJG6BdW2MfPdWkvawncccGkdo"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2442106,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: BBHpcy3MTZPjYp2kx7aJK39Nw1FD1fqDJ9C8ScAxy8T
Next: 9HajWY2gqWuyC1i3pCZYg4QDe7ijQpPX36NbWtEhxj6V

Diff: 
Old
New
Differences
72
72
 
func keyAllowedLpStableAddonScriptHash () = "%s__allowedLpStableAddonScriptHash"
73
73
 
74
74
 
75
-
func swapContract () = "%s__swapContract"
76
-
77
-
78
75
 
func keyFactoryConfig () = "%s__factoryConfig"
79
76
 
80
77
 
136
133
 
137
134
 
138
135
 
func keyPoolOneTokenOperationsDisabled (assetsInternal) = {
139
-
    let $t037003762 = assetsInternal
140
-
    let amountAssetInternal = $t037003762._1
141
-
    let priceAssetInternal = $t037003762._2
136
+
    let $t036323694 = assetsInternal
137
+
    let amountAssetInternal = $t036323694._1
138
+
    let priceAssetInternal = $t036323694._2
142
139
 
    makeString(["%d%d%s", toString(amountAssetInternal), toString(priceAssetInternal), "oneTokenOperationsDisabled"], SEP)
143
140
 
    }
144
141
 
257
254
 
258
255
 
let permissionDeniedError = throw("Permission denied")
259
256
 
260
-
let testError = throw("Test error here")
261
-
262
257
 
func mustThis (i) = if ((i.caller == this))
263
258
 
    then true
264
259
 
    else permissionDeniedError
323
318
 
324
319
 
325
320
 
func intOrDefaultOrFallback (key,keyDefault,valueFallback) = valueOrElse(getInteger(this, key), valueOrElse(getInteger(this, keyDefault), valueFallback))
326
-
327
-
328
-
@Callable(i)
329
-
func getSwapContractREADONLY () = $Tuple2(nil, getStringOrFail(swapContract()))
330
-
331
-
332
-
333
-
@Callable(i)
334
-
func getLpAssetFromPoolAssetsREADONLY (asset1,asset2) = {
335
-
    let assetNum1 = value(getInteger(this, keyMappingsBaseAsset2internalId(asset1)))
336
-
    let assetNum2 = value(getInteger(this, keyMappingsBaseAsset2internalId(asset2)))
337
-
    let ee = getString(this, keyMappingPoolAssetsToLpasset(toString(assetNum1), toString(assetNum2)))
338
-
    let res = if ((ee == unit))
339
-
        then unit
340
-
        else drop(value(ee), 4)
341
-
    $Tuple2(nil, res)
342
-
    }
343
-
344
-
345
-
346
-
@Callable(i)
347
-
func getPoolAddressFromLpAssetREADONLY (lp) = $Tuple2(nil, valueOrElse(getString(this, keyMappingPoolLPAssetToPoolContractAddress(lp)), ""))
348
-
349
321
 
350
322
 
351
323
 
@Callable(i)
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SCALE8 = 8
5
5
 
6
6
 
let MULT8 = 100000000
7
7
 
8
8
 
let SCALE18 = 18
9
9
 
10
10
 
let MULT18 = toBigInt(1000000000000000000)
11
11
 
12
12
 
let POOLWEIGHTMULT = MULT8
13
13
 
14
14
 
let GWXvirtualPOOL = "GWXvirtualPOOL"
15
15
 
16
16
 
let labelPoolsLp = "POOLS_LP"
17
17
 
18
18
 
let defaultSpread = 2000000
19
19
 
20
20
 
let decimalsMultPrice = ((100 * 1000) * 1000)
21
21
 
22
22
 
let SEP = "__"
23
23
 
24
24
 
let EMPTY = ""
25
25
 
26
26
 
let PoolActive = 1
27
27
 
28
28
 
let PoolPutDisabled = 2
29
29
 
30
30
 
let PoolMatcherDisabled = 3
31
31
 
32
32
 
let PoolShutdown = 4
33
33
 
34
34
 
let idxInternalAssetId = 1
35
35
 
36
36
 
let idxResutActions = 2
37
37
 
38
38
 
let idxIfAssetIdCalculationPerformed = 3
39
39
 
40
40
 
let idxPoolAddress = 1
41
41
 
42
42
 
let idxPoolStatus = 2
43
43
 
44
44
 
let idxPoolLPAssetId = 3
45
45
 
46
46
 
let idxAmtAssetId = 4
47
47
 
48
48
 
let idxPriceAssetId = 5
49
49
 
50
50
 
let idxAmtAssetDcm = 6
51
51
 
52
52
 
let idxPriceAssetDcm = 7
53
53
 
54
54
 
let idxIAmtAssetId = 8
55
55
 
56
56
 
let idxIPriceAssetId = 9
57
57
 
58
58
 
let idxLPAssetDcm = 10
59
59
 
60
60
 
let idxPoolType = 11
61
61
 
62
62
 
let poolLabelWxEmission = "WX_EMISSION"
63
63
 
64
64
 
let validPoolLabels = [poolLabelWxEmission]
65
65
 
66
66
 
func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
67
67
 
68
68
 
69
69
 
func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
70
70
 
71
71
 
72
72
 
func keyAllowedLpStableAddonScriptHash () = "%s__allowedLpStableAddonScriptHash"
73
73
 
74
74
 
75
-
func swapContract () = "%s__swapContract"
76
-
77
-
78
75
 
func keyFactoryConfig () = "%s__factoryConfig"
79
76
 
80
77
 
81
78
 
func keyLpTokensList () = "%s__lpTokensList"
82
79
 
83
80
 
84
81
 
func keyPoolScriptHash () = "%s%s__pool__scriptHash"
85
82
 
86
83
 
87
84
 
func keyMatcherPub () = "%s%s__matcher__publicKey"
88
85
 
89
86
 
90
87
 
func keyLegacyFactoryContract () = "%s__legacyFactoryContract"
91
88
 
92
89
 
93
90
 
func keyLegacyPools () = "%s__legacyPools"
94
91
 
95
92
 
96
93
 
func keyManagerPublicKey () = "%s__managerPublicKey"
97
94
 
98
95
 
99
96
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
100
97
 
101
98
 
102
99
 
func keyAdminPubKeys () = "%s__adminPubKeys"
103
100
 
104
101
 
105
102
 
func keyAssetsStoreContract () = "%s__assetsStoreContract"
106
103
 
107
104
 
108
105
 
func keyVotingEmissionContract () = "%s__votingEmissionContract"
109
106
 
110
107
 
111
108
 
func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
112
109
 
113
110
 
114
111
 
func keyPriceDecimals () = "%s__priceDecimals"
115
112
 
116
113
 
117
114
 
func keyAllPoolsShutdown () = "%s__shutdown"
118
115
 
119
116
 
120
117
 
func keyNextInternalAssetId () = "%s__nextInternalAssetId"
121
118
 
122
119
 
123
120
 
func keyPoolToWeight (poolAddress) = ("%s%s__poolWeight__" + poolAddress)
124
121
 
125
122
 
126
123
 
func keyPoolToWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
127
124
 
128
125
 
129
126
 
func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
130
127
 
131
128
 
132
129
 
func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
133
130
 
134
131
 
135
132
 
func keyPoolConfig (amountAssetInternal,priceAssetInternal) = (((("%d%d%s__" + amountAssetInternal) + "__") + priceAssetInternal) + "__config")
136
133
 
137
134
 
138
135
 
func keyPoolOneTokenOperationsDisabled (assetsInternal) = {
139
-
    let $t037003762 = assetsInternal
140
-
    let amountAssetInternal = $t037003762._1
141
-
    let priceAssetInternal = $t037003762._2
136
+
    let $t036323694 = assetsInternal
137
+
    let amountAssetInternal = $t036323694._1
138
+
    let priceAssetInternal = $t036323694._2
142
139
 
    makeString(["%d%d%s", toString(amountAssetInternal), toString(priceAssetInternal), "oneTokenOperationsDisabled"], SEP)
143
140
 
    }
144
141
 
145
142
 
146
143
 
func keyAllPoolsOneTokenOperationsDisabled () = makeString(["%s", "oneTokenOperationsDisabled"], SEP)
147
144
 
148
145
 
149
146
 
func keyMappingLpAssetToPoolAssets (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2Pool")
150
147
 
151
148
 
152
149
 
func keyMappingPoolAssetsToLpasset (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + internalAmountAssetIdStr) + "__") + internalPriceAssetIdStr) + "__mappings__PoolAssets2LpAsset")
153
150
 
154
151
 
155
152
 
func keyPoolSpread (poolAddress) = ("%s%s__spread__" + poolAddress)
156
153
 
157
154
 
158
155
 
func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
159
156
 
160
157
 
161
158
 
func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
162
159
 
163
160
 
164
161
 
func keyMappingPoolContractToLPAsset (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
165
162
 
166
163
 
167
164
 
func keyMappingPoolLPAssetToPoolContractAddress (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2PoolContract")
168
165
 
169
166
 
170
167
 
func keyWxEmission (amountAssetId,priceAssetId) = ((("%s%s%s__wxEmission__" + amountAssetId) + "__") + priceAssetId)
171
168
 
172
169
 
173
170
 
func keyInFee (poolAddress) = ("%s%s__inFee__" + poolAddress)
174
171
 
175
172
 
176
173
 
func keyInFeeDefault () = "%s__inFeeDefault"
177
174
 
178
175
 
179
176
 
func keyOutFee (poolAddress) = ("%s%s__outFee__" + poolAddress)
180
177
 
181
178
 
182
179
 
func keyOutFeeDefault () = "%s__outFeeDefault"
183
180
 
184
181
 
185
182
 
func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
186
183
 
187
184
 
188
185
 
func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
189
186
 
190
187
 
191
188
 
func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
192
189
 
193
190
 
194
191
 
let IdxFactoryCfgStakingDapp = 1
195
192
 
196
193
 
let IdxFactoryCfgBoostingDapp = 2
197
194
 
198
195
 
let IdxFactoryCfgIdoDapp = 3
199
196
 
200
197
 
let IdxFactoryCfgTeamDapp = 4
201
198
 
202
199
 
let IdxFactoryCfgEmissionDapp = 5
203
200
 
204
201
 
let IdxFactoryCfgRestDapp = 6
205
202
 
206
203
 
let IdxFactoryCfgSlippageDapp = 7
207
204
 
208
205
 
let IdxFactoryCfgDaoDapp = 8
209
206
 
210
207
 
let IdxFactoryCfgMarketingDapp = 9
211
208
 
212
209
 
let IdxFactoryCfgGwxRewardDapp = 10
213
210
 
214
211
 
let IdxFactoryCfgBirdsDapp = 11
215
212
 
216
213
 
func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
217
214
 
218
215
 
219
216
 
func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
220
217
 
221
218
 
222
219
 
func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
223
220
 
224
221
 
225
222
 
func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
226
223
 
227
224
 
228
225
 
func getPriceAssets () = match getString(keyPriceAssets()) {
229
226
 
    case s: String => 
230
227
 
        if ((size(s) == 0))
231
228
 
            then nil
232
229
 
            else split(s, SEP)
233
230
 
    case _ => 
234
231
 
        nil
235
232
 
}
236
233
 
237
234
 
238
235
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
239
236
 
    case s: String => 
240
237
 
        fromBase58String(s)
241
238
 
    case _: Unit => 
242
239
 
        unit
243
240
 
    case _ => 
244
241
 
        throw("Match error")
245
242
 
}
246
243
 
247
244
 
248
245
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
249
246
 
    case s: String => 
250
247
 
        fromBase58String(s)
251
248
 
    case _: Unit => 
252
249
 
        unit
253
250
 
    case _ => 
254
251
 
        throw("Match error")
255
252
 
}
256
253
 
257
254
 
258
255
 
let permissionDeniedError = throw("Permission denied")
259
256
 
260
-
let testError = throw("Test error here")
261
-
262
257
 
func mustThis (i) = if ((i.caller == this))
263
258
 
    then true
264
259
 
    else permissionDeniedError
265
260
 
266
261
 
267
262
 
func mustManager (i) = match managerPublicKeyOrUnit() {
268
263
 
    case pk: ByteVector => 
269
264
 
        if ((i.callerPublicKey == pk))
270
265
 
            then true
271
266
 
            else permissionDeniedError
272
267
 
    case _: Unit => 
273
268
 
        mustThis(i)
274
269
 
    case _ => 
275
270
 
        throw("Match error")
276
271
 
}
277
272
 
278
273
 
279
274
 
func dataFactoryCfgV3 (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract,daoContract,marketingContract,gwxRewardsContract,birdsContract) = makeString(["%s%s%s%s%s%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract, daoContract, marketingContract, gwxRewardsContract, birdsContract], SEP)
280
275
 
281
276
 
282
277
 
func dataFactoryCfg (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract) = makeString(["%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract], SEP)
283
278
 
284
279
 
285
280
 
func dataPoolCfg (poolAddress,poolStatus,lpAssetId,amountAssetStr,priceAssetStr,amountAssetDecimals,priceAssetDecimals,amountAssetInternalId,priceAssetInternalId,lpAssetDecimals,poolType) = makeString(["%s%d%s%s%s%d%d%d%d%d%s", poolAddress, poolStatus, lpAssetId, amountAssetStr, priceAssetStr, toString(amountAssetDecimals), toString(priceAssetDecimals), toString(amountAssetInternalId), toString(priceAssetInternalId), toString(lpAssetDecimals), poolType], SEP)
286
281
 
287
282
 
288
283
 
func dataMappingPoolAssets (internalAmountAssetStr,internalPriceAssetStr) = makeString(["%d%d", toString(internalAmountAssetStr), toString(internalPriceAssetStr)], SEP)
289
284
 
290
285
 
291
286
 
func getPoolConfig (poolAddress) = {
292
287
 
    let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
293
288
 
    let amountAssetInternal = poolAssets[1]
294
289
 
    let priceAssetInternal = poolAssets[2]
295
290
 
    split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
296
291
 
    }
297
292
 
298
293
 
299
294
 
func getInternalAssetIdOrCreate (assetIdStr,incrementor) = {
300
295
 
    let internalAssetId = valueOrElse(getInteger(this, keyMappingsBaseAsset2internalId(assetIdStr)), 0)
301
296
 
    let currentIndexOfInternalId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
302
297
 
    let result = if ((internalAssetId == 0))
303
298
 
        then {
304
299
 
            let newInternalAssetId = (currentIndexOfInternalId + incrementor)
305
300
 
            $Tuple3(newInternalAssetId, [IntegerEntry(keyNextInternalAssetId(), newInternalAssetId), IntegerEntry(keyMappingsBaseAsset2internalId(assetIdStr), newInternalAssetId), StringEntry(keyMappingsInternal2baseAssetId(newInternalAssetId), assetIdStr)], true)
306
301
 
            }
307
302
 
        else $Tuple3(internalAssetId, nil, false)
308
303
 
    result
309
304
 
    }
310
305
 
311
306
 
312
307
 
func mustAdmin (i) = {
313
308
 
    let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
314
309
 
    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
315
310
 
        then true
316
311
 
        else {
317
312
 
            let isManager = mustManager(i)
318
313
 
            if ((isManager == isManager))
319
314
 
                then true
320
315
 
                else throw("Strict value is not equal to itself.")
321
316
 
            }
322
317
 
    }
323
318
 
324
319
 
325
320
 
func intOrDefaultOrFallback (key,keyDefault,valueFallback) = valueOrElse(getInteger(this, key), valueOrElse(getInteger(this, keyDefault), valueFallback))
326
-
327
-
328
-
@Callable(i)
329
-
func getSwapContractREADONLY () = $Tuple2(nil, getStringOrFail(swapContract()))
330
-
331
-
332
-
333
-
@Callable(i)
334
-
func getLpAssetFromPoolAssetsREADONLY (asset1,asset2) = {
335
-
    let assetNum1 = value(getInteger(this, keyMappingsBaseAsset2internalId(asset1)))
336
-
    let assetNum2 = value(getInteger(this, keyMappingsBaseAsset2internalId(asset2)))
337
-
    let ee = getString(this, keyMappingPoolAssetsToLpasset(toString(assetNum1), toString(assetNum2)))
338
-
    let res = if ((ee == unit))
339
-
        then unit
340
-
        else drop(value(ee), 4)
341
-
    $Tuple2(nil, res)
342
-
    }
343
-
344
-
345
-
346
-
@Callable(i)
347
-
func getPoolAddressFromLpAssetREADONLY (lp) = $Tuple2(nil, valueOrElse(getString(this, keyMappingPoolLPAssetToPoolContractAddress(lp)), ""))
348
-
349
321
 
350
322
 
351
323
 
@Callable(i)
352
324
 
func constructor (stakingContract,boostingContract,idoContract,teamContract,emissionContract,restContract,slpipageContract,priceDecimals) = {
353
325
 
    let checkCaller = mustManager(i)
354
326
 
    if ((checkCaller == checkCaller))
355
327
 
        then [StringEntry(keyFactoryConfig(), dataFactoryCfg(stakingContract, boostingContract, idoContract, teamContract, emissionContract, restContract, slpipageContract)), IntegerEntry(keyPriceDecimals(), priceDecimals)]
356
328
 
        else throw("Strict value is not equal to itself.")
357
329
 
    }
358
330
 
359
331
 
360
332
 
361
333
 
@Callable(i)
362
334
 
func constructorV2 (mathcherPub58Str) = {
363
335
 
    let checkCaller = mustManager(i)
364
336
 
    if ((checkCaller == checkCaller))
365
337
 
        then {
366
338
 
            let mathcerPub = addressFromPublicKey(fromBase58String(mathcherPub58Str))
367
339
 
            if ((mathcerPub == mathcerPub))
368
340
 
                then [StringEntry(keyMatcherPub(), mathcherPub58Str)]
369
341
 
                else throw("Strict value is not equal to itself.")
370
342
 
            }
371
343
 
        else throw("Strict value is not equal to itself.")
372
344
 
    }
373
345
 
374
346
 
375
347
 
376
348
 
@Callable(i)
377
349
 
func constructorV3 (daoContract,marketingContract,gwxRewardsContract,birdsContract) = {
378
350
 
    let checkCaller = mustManager(i)
379
351
 
    if ((checkCaller == checkCaller))
380
352
 
        then {
381
353
 
            let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
382
354
 
[StringEntry(keyFactoryConfig(), dataFactoryCfgV3(factoryCfg[1], factoryCfg[2], factoryCfg[3], factoryCfg[4], factoryCfg[5], factoryCfg[6], factoryCfg[7], daoContract, marketingContract, gwxRewardsContract, birdsContract))]
383
355
 
            }
384
356
 
        else throw("Strict value is not equal to itself.")
385
357
 
    }
386
358
 
387
359
 
388
360
 
389
361
 
@Callable(i)
390
362
 
func constructorV4 (legacyFactoryContract,legacyPools) = {
391
363
 
    let checkCaller = mustManager(i)
392
364
 
    if ((checkCaller == checkCaller))
393
365
 
        then [StringEntry(keyLegacyFactoryContract(), legacyFactoryContract), StringEntry(keyLegacyPools(), makeString(legacyPools, SEP))]
394
366
 
        else throw("Strict value is not equal to itself.")
395
367
 
    }
396
368
 
397
369
 
398
370
 
399
371
 
@Callable(i)
400
372
 
func constructorV5 (assetsStoreContract) = {
401
373
 
    let checkCaller = mustManager(i)
402
374
 
    if ((checkCaller == checkCaller))
403
375
 
        then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
404
376
 
        else throw("Strict value is not equal to itself.")
405
377
 
    }
406
378
 
407
379
 
408
380
 
409
381
 
@Callable(i)
410
382
 
func constructorV6 (votingEmissionContract,priceAssets) = {
411
383
 
    let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
412
384
 
        then true
413
385
 
        else "invalid voting emission contract address"]
414
386
 
    if ((cheks == cheks))
415
387
 
        then [StringEntry(keyVotingEmissionContract(), votingEmissionContract), StringEntry(keyPriceAssets(), makeString(priceAssets, SEP))]
416
388
 
        else throw("Strict value is not equal to itself.")
417
389
 
    }
418
390
 
419
391
 
420
392
 
421
393
 
@Callable(i)
422
394
 
func setManager (pendingManagerPublicKey) = {
423
395
 
    let checkCaller = mustManager(i)
424
396
 
    if ((checkCaller == checkCaller))
425
397
 
        then {
426
398
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
427
399
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
428
400
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
429
401
 
                else throw("Strict value is not equal to itself.")
430
402
 
            }
431
403
 
        else throw("Strict value is not equal to itself.")
432
404
 
    }
433
405
 
434
406
 
435
407
 
436
408
 
@Callable(i)
437
409
 
func confirmManager () = {
438
410
 
    let pm = pendingManagerPublicKeyOrUnit()
439
411
 
    let hasPM = if (isDefined(pm))
440
412
 
        then true
441
413
 
        else throw("No pending manager")
442
414
 
    if ((hasPM == hasPM))
443
415
 
        then {
444
416
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
445
417
 
                then true
446
418
 
                else throw("You are not pending manager")
447
419
 
            if ((checkPM == checkPM))
448
420
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
449
421
 
                else throw("Strict value is not equal to itself.")
450
422
 
            }
451
423
 
        else throw("Strict value is not equal to itself.")
452
424
 
    }
453
425
 
454
426
 
455
427
 
456
428
 
@Callable(i)
457
429
 
func setAdmins (adminPubKeys) = {
458
430
 
    let checkCaller = mustManager(i)
459
431
 
    if ((checkCaller == checkCaller))
460
432
 
        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
461
433
 
        else throw("Strict value is not equal to itself.")
462
434
 
    }
463
435
 
464
436
 
465
437
 
466
438
 
@Callable(i)
467
439
 
func activateNewPool (poolAddress,amountAssetStr,priceAssetStr,lpAssetName,lpAssetDescr,poolWeight,poolType,logo) = {
468
440
 
    let checkCaller = mustAdmin(i)
469
441
 
    if ((checkCaller == checkCaller))
470
442
 
        then if (isDefined(getString(keyMappingPoolContractAddressToPoolAssets(poolAddress))))
471
443
 
            then throw((("Pool address " + poolAddress) + " already registered."))
472
444
 
            else {
473
445
 
                let internalAmountAssetData = getInternalAssetIdOrCreate(amountAssetStr, 1)
474
446
 
                let internalAmountAssetId = internalAmountAssetData._1
475
447
 
                let internalPriceAssetData = getInternalAssetIdOrCreate(priceAssetStr, if (internalAmountAssetData._3)
476
448
 
                    then 2
477
449
 
                    else 1)
478
450
 
                let internalPriceAssetId = internalPriceAssetData._1
479
451
 
                let poolAccountScriptHash = valueOrErrorMessage(scriptHash(addressFromStringValue(poolAddress)), ("No script has been found on pool account " + poolAddress))
480
452
 
                let ethalonPoolAccountScriptHash = getBinaryValue(keyPoolScriptHash())
481
453
 
                let poolConfig = getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)))
482
454
 
                if (isDefined(poolConfig))
483
455
 
                    then throw((((("Pool " + amountAssetStr) + "/") + priceAssetStr) + " has already been activated."))
484
456
 
                    else {
485
457
 
                        let poolConfigValue = value(getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId))))
486
458
 
                        let amountAssetsDecimals = if ((amountAssetStr == "WAVES"))
487
459
 
                            then decimalsMultPrice
488
460
 
                            else pow(10, 0, value(assetInfo(fromBase58String(amountAssetStr))).decimals, 0, 0, DOWN)
489
461
 
                        let priceAssetsDecimals = if ((priceAssetStr == "WAVES"))
490
462
 
                            then decimalsMultPrice
491
463
 
                            else pow(10, 0, value(assetInfo(fromBase58String(priceAssetStr))).decimals, 0, 0, DOWN)
492
464
 
                        let lpAssetIssueAction = Issue(lpAssetName, lpAssetDescr, 1, 8, true)
493
465
 
                        let lpAssetId = calculateAssetId(lpAssetIssueAction)
494
466
 
                        let lpAssetIdStr = toBase58String(lpAssetId)
495
467
 
                        let poolActivateInvokeResult = invoke(addressFromStringValue(poolAddress), "activate", [amountAssetStr, priceAssetStr], nil)
496
468
 
                        if ((poolActivateInvokeResult == poolActivateInvokeResult))
497
469
 
                            then if ((poolActivateInvokeResult != "success"))
498
470
 
                                then throw("Pool initialisation error happened.")
499
471
 
                                else {
500
472
 
                                    let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract()))
501
473
 
                                    let createOrUpdateLpAssetInv = invoke(assetsStoreContract, "createOrUpdate", [lpAssetIdStr, lpAssetName, false], nil)
502
474
 
                                    if ((createOrUpdateLpAssetInv == createOrUpdateLpAssetInv))
503
475
 
                                        then {
504
476
 
                                            let addPoolsLpLabelInv = invoke(assetsStoreContract, "addLabel", [lpAssetIdStr, labelPoolsLp], nil)
505
477
 
                                            if ((addPoolsLpLabelInv == addPoolsLpLabelInv))
506
478
 
                                                then {
507
479
 
                                                    let setLogoInv = invoke(assetsStoreContract, "setLogo", [lpAssetIdStr, logo], nil)
508
480
 
                                                    if ((setLogoInv == setLogoInv))
509
481
 
                                                        then {
510
482
 
                                                            let addAssetsLinkInv = invoke(assetsStoreContract, "addAssetsLink", [amountAssetStr, priceAssetStr, lpAssetIdStr], nil)
511
483
 
                                                            if ((addAssetsLinkInv == addAssetsLinkInv))
512
484
 
                                                                then {
513
485
 
                                                                    let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
514
486
 
                                                                    if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
515
487
 
                                                                        then $Tuple2(((internalAmountAssetData._2 ++ internalPriceAssetData._2) ++ [lpAssetIssueAction, Burn(lpAssetId, 1), StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(PoolActive), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, decimalsMultPrice, poolType)), StringEntry(keyMappingLpAssetToPoolAssets(lpAssetIdStr), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToLpasset(toString(internalAmountAssetId), toString(internalPriceAssetId)), ("%s__" + lpAssetIdStr)), StringEntry(keyMappingPoolContractAddressToPoolAssets(poolAddress), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToPoolContractAddress(internalAmountAssetId, internalPriceAssetId), poolAddress), StringEntry(keyMappingPoolLPAssetToPoolContractAddress(lpAssetIdStr), poolAddress), StringEntry(keyMappingPoolContractToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight), IntegerEntry(keyPoolSpread(poolAddress), defaultSpread)]), lpAssetIdStr)
516
488
 
                                                                        else throw("Strict value is not equal to itself.")
517
489
 
                                                                    }
518
490
 
                                                                else throw("Strict value is not equal to itself.")
519
491
 
                                                            }
520
492
 
                                                        else throw("Strict value is not equal to itself.")
521
493
 
                                                    }
522
494
 
                                                else throw("Strict value is not equal to itself.")
523
495
 
                                            }
524
496
 
                                        else throw("Strict value is not equal to itself.")
525
497
 
                                    }
526
498
 
                            else throw("Strict value is not equal to itself.")
527
499
 
                        }
528
500
 
                }
529
501
 
        else throw("Strict value is not equal to itself.")
530
502
 
    }
531
503
 
532
504
 
533
505
 
534
506
 
@Callable(i)
535
507
 
func managePool (poolAddress,newStatus) = {
536
508
 
    let checkCaller = mustManager(i)
537
509
 
    if ((checkCaller == checkCaller))
538
510
 
        then {
539
511
 
            let poolConfig = getPoolConfig(poolAddress)
540
512
 
            let poolStatus = poolConfig[idxPoolStatus]
541
513
 
            let lpAssetIdStr = poolConfig[idxPoolLPAssetId]
542
514
 
            let amountAssetStr = poolConfig[idxAmtAssetId]
543
515
 
            let priceAssetStr = poolConfig[idxPriceAssetId]
544
516
 
            let amountAssetsDecimals = parseIntValue(poolConfig[idxAmtAssetDcm])
545
517
 
            let priceAssetsDecimals = parseIntValue(poolConfig[idxPriceAssetDcm])
546
518
 
            let internalAmountAssetId = parseIntValue(poolConfig[idxIAmtAssetId])
547
519
 
            let internalPriceAssetId = parseIntValue(poolConfig[idxIPriceAssetId])
548
520
 
            let lpAssetDcm = parseIntValue(poolConfig[idxLPAssetDcm])
549
521
 
            let poolType = poolConfig[idxPoolType]
550
522
 
[StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(newStatus), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, lpAssetDcm, poolType))]
551
523
 
            }
552
524
 
        else throw("Strict value is not equal to itself.")
553
525
 
    }
554
526
 
555
527
 
556
528
 
557
529
 
@Callable(i)
558
530
 
func emit (amountToEmit) = {
559
531
 
    let caller = i.caller
560
532
 
    let originCaller = i.originCaller
561
533
 
    let lpAssetRequested = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
562
534
 
    let lpAsset = fromBase58String(lpAssetRequested)
563
535
 
    let legacyPools = split(valueOrElse(getString(keyLegacyPools()), EMPTY), SEP)
564
536
 
    let legacyFactoryContract = addressFromStringValue(valueOrErrorMessage(getString(keyLegacyFactoryContract()), "Legacy factory contract does not exists."))
565
537
 
    if ((0 >= amountToEmit))
566
538
 
        then nil
567
539
 
        else if (containsElement(legacyPools, toString(caller)))
568
540
 
            then $Tuple2(nil, legacyFactoryContract)
569
541
 
            else $Tuple2([Reissue(lpAsset, amountToEmit, true), ScriptTransfer(i.caller, amountToEmit, lpAsset)], "success")
570
542
 
    }
571
543
 
572
544
 
573
545
 
574
546
 
@Callable(i)
575
547
 
func burn (amountToBurn) = {
576
548
 
    let caller = i.caller
577
549
 
    let originCaller = i.originCaller
578
550
 
    let payment = value(i.payments[0])
579
551
 
    let paymentAmount = value(payment.amount)
580
552
 
    let inAmountAssetId = toBase58String(value(payment.assetId))
581
553
 
    let lpAssetRequestedForBurning = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
582
554
 
    if ((inAmountAssetId != lpAssetRequestedForBurning))
583
555
 
        then throw("Invalid asset passed.")
584
556
 
        else if ((amountToBurn != paymentAmount))
585
557
 
            then throw("Invalid amount passed.")
586
558
 
            else {
587
559
 
                let lpAsset = fromBase58String(lpAssetRequestedForBurning)
588
560
 
                $Tuple2([Burn(lpAsset, amountToBurn)], "success")
589
561
 
                }
590
562
 
    }
591
563
 
592
564
 
593
565
 
594
566
 
@Callable(i)
595
567
 
func modifyWeight (lpAssetId,share) = {
596
568
 
    let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
597
569
 
        then true
598
570
 
        else mustManager(i)
599
571
 
    if ((checkCaller == checkCaller))
600
572
 
        then {
601
573
 
            let poolContractAddress = getStringOrFail(keyMappingPoolLPAssetToPoolContractAddress(lpAssetId))
602
574
 
            let poolWeightKey = keyPoolToWeight(poolContractAddress)
603
575
 
            let gwxWeightKey = keyPoolToWeight(GWXvirtualPOOL)
604
576
 
            let gwxWeight = valueOrElse(getInteger(gwxWeightKey), 0)
605
577
 
            let poolWeight = valueOrElse(getInteger(poolWeightKey), 0)
606
578
 
            let poolWeightNew = share
607
579
 
            let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
608
580
 
            let stakingContract = getStakingAddressOrFail(factoryCfg)
609
581
 
            let onModifyWeightInv = invoke(stakingContract, "onModifyWeight", [lpAssetId, poolContractAddress], nil)
610
582
 
            if ((onModifyWeightInv == onModifyWeightInv))
611
583
 
                then {
612
584
 
                    let gwxVirtualPoolActions = if ((gwxWeight == 0))
613
585
 
                        then nil
614
586
 
                        else [IntegerEntry(gwxWeightKey, 0)]
615
587
 
                    let poolWeightHistoryKey = keyPoolToWeightHistory(poolContractAddress, 0)
616
588
 
                    let poolWeightHistoryOrUnit = getInteger(poolWeightHistoryKey)
617
589
 
                    let poolWeightHistoryActions = if ((poolWeightHistoryOrUnit == unit))
618
590
 
                        then nil
619
591
 
                        else [DeleteEntry(poolWeightHistoryKey)]
620
592
 
                    (([IntegerEntry(poolWeightKey, poolWeightNew)] ++ gwxVirtualPoolActions) ++ poolWeightHistoryActions)
621
593
 
                    }
622
594
 
                else throw("Strict value is not equal to itself.")
623
595
 
            }
624
596
 
        else throw("Strict value is not equal to itself.")
625
597
 
    }
626
598
 
627
599
 
628
600
 
629
601
 
@Callable(i)
630
602
 
func modifyWeights (btcPoolAddress,ethPoolAddress,ethBtcPoolAddress,usdcUsdtPoolAddress) = {
631
603
 
    let checkCaller = mustManager(i)
632
604
 
    if ((checkCaller == checkCaller))
633
605
 
        then {
634
606
 
            let ethBtcWeightNew = ((5 * POOLWEIGHTMULT) / 100)
635
607
 
            let usdcUsdtWeightNew = ((5 * POOLWEIGHTMULT) / 100)
636
608
 
            let weightDecrement = ((5 * POOLWEIGHTMULT) / 100)
637
609
 
            let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
638
610
 
            let stakingDapp = getStakingAddressOrFail(factoryCfg)
639
611
 
            let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
640
612
 
            let btcWeightKEY = keyPoolToWeight(btcPoolAddress)
641
613
 
            let ethWeightKEY = keyPoolToWeight(ethPoolAddress)
642
614
 
            let ethBtcWeightKEY = keyPoolToWeight(ethBtcPoolAddress)
643
615
 
            let usdcUsdtWeightKEY = keyPoolToWeight(usdcUsdtPoolAddress)
644
616
 
            let btcWeight = getIntOrFail(btcWeightKEY)
645
617
 
            let ethWeight = getIntOrFail(ethWeightKEY)
646
618
 
            let btcWeightNew = (btcWeight - weightDecrement)
647
619
 
            let ethWeightNew = (ethWeight - weightDecrement)
648
620
 
            if ((0 >= btcWeightNew))
649
621
 
                then throw(("invalid btcWeightNew: " + toString(btcWeightNew)))
650
622
 
                else if ((0 >= ethWeightNew))
651
623
 
                    then throw(("invalid ethWeightNew: " + toString(ethWeightNew)))
652
624
 
                    else {
653
625
 
                        let btcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(btcPoolAddress))
654
626
 
                        let ethLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethPoolAddress))
655
627
 
                        let ethBtcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethBtcPoolAddress))
656
628
 
                        let usdcUsdtLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(usdcUsdtPoolAddress))
657
629
 
                        let onModifyWeightBtc = invoke(stakingDapp, "onModifyWeight", [btcLpAssetIdStr, btcPoolAddress], nil)
658
630
 
                        if ((onModifyWeightBtc == onModifyWeightBtc))
659
631
 
                            then {
660
632
 
                                let onModifyWeightEth = invoke(stakingDapp, "onModifyWeight", [ethLpAssetIdStr, ethPoolAddress], nil)
661
633
 
                                if ((onModifyWeightEth == onModifyWeightEth))
662
634
 
                                    then {
663
635
 
                                        let onModifyWeightEthBtc = invoke(stakingDapp, "onModifyWeight", [ethBtcLpAssetIdStr, ethBtcPoolAddress], nil)
664
636
 
                                        if ((onModifyWeightEthBtc == onModifyWeightEthBtc))
665
637
 
                                            then {
666
638
 
                                                let onModifyWeightUsdcUsdt = invoke(stakingDapp, "onModifyWeight", [usdcUsdtLpAssetIdStr, usdcUsdtPoolAddress], nil)
667
639
 
                                                if ((onModifyWeightUsdcUsdt == onModifyWeightUsdcUsdt))
668
640
 
                                                    then [IntegerEntry(btcWeightKEY, btcWeightNew), IntegerEntry(ethWeightKEY, ethWeightNew), IntegerEntry(ethBtcWeightKEY, ethBtcWeightNew), IntegerEntry(usdcUsdtWeightKEY, usdcUsdtWeightNew), IntegerEntry(keyPoolToWeightHistory(btcPoolAddress, 0), btcWeight), IntegerEntry(keyPoolToWeightHistory(ethPoolAddress, 0), ethWeight), IntegerEntry(keyPoolToWeightHistory(ethBtcPoolAddress, 0), ethBtcWeightNew), IntegerEntry(keyPoolToWeightHistory(usdcUsdtPoolAddress, 0), usdcUsdtWeightNew)]
669
641
 
                                                    else throw("Strict value is not equal to itself.")
670
642
 
                                                }
671
643
 
                                            else throw("Strict value is not equal to itself.")
672
644
 
                                        }
673
645
 
                                    else throw("Strict value is not equal to itself.")
674
646
 
                                }
675
647
 
                            else throw("Strict value is not equal to itself.")
676
648
 
                        }
677
649
 
            }
678
650
 
        else throw("Strict value is not equal to itself.")
679
651
 
    }
680
652
 
681
653
 
682
654
 
683
655
 
@Callable(i)
684
656
 
func checkWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
685
657
 
    let haveLabel =     match getBoolean(keyWxEmission(amountAssetId, priceAssetId)) {
686
658
 
        case b: Boolean => 
687
659
 
            b
688
660
 
        case _ => 
689
661
 
            false
690
662
 
    }
691
663
 
    $Tuple2(nil, haveLabel)
692
664
 
    }
693
665
 
694
666
 
695
667
 
696
668
 
@Callable(i)
697
669
 
func setWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
698
670
 
    let checkCaller = mustAdmin(i)
699
671
 
    if ((checkCaller == checkCaller))
700
672
 
        then $Tuple2([BooleanEntry(keyWxEmission(amountAssetId, priceAssetId), true)], unit)
701
673
 
        else throw("Strict value is not equal to itself.")
702
674
 
    }
703
675
 
704
676
 
705
677
 
706
678
 
@Callable(i)
707
679
 
func deleteWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
708
680
 
    let checkCaller = if (mustThis(i))
709
681
 
        then true
710
682
 
        else mustAdmin(i)
711
683
 
    if ((checkCaller == checkCaller))
712
684
 
        then $Tuple2([DeleteEntry(keyWxEmission(amountAssetId, priceAssetId))], unit)
713
685
 
        else throw("Strict value is not equal to itself.")
714
686
 
    }
715
687
 
716
688
 
717
689
 
718
690
 
@Callable(i)
719
691
 
func onVerificationLoss (assetId) = {
720
692
 
    let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyAssetsStoreContract()), "")))
721
693
 
        then true
722
694
 
        else mustManager(i)
723
695
 
    if ((checkCaller == checkCaller))
724
696
 
        then {
725
697
 
            let priceAssets = getPriceAssets()
726
698
 
            let checkPriceAssetsSize = if ((size(priceAssets) > 0))
727
699
 
                then true
728
700
 
                else throw("invalid price assets")
729
701
 
            if ((checkPriceAssetsSize == checkPriceAssetsSize))
730
702
 
                then {
731
703
 
                    func cb (acc,priceAsset) =                     {
732
704
 
                        let r = invoke(this, "deleteWxEmissionPoolLabel", [assetId, priceAsset], nil)
733
705
 
                        if ((r == r))
734
706
 
                            then unit
735
707
 
                            else throw("Strict value is not equal to itself.")
736
708
 
                        }
737
709
 
738
710
 
                    let actions = {
739
711
 
                        let $l = priceAssets
740
712
 
                        let $s = size($l)
741
713
 
                        let $acc0 = unit
742
714
 
                        func $f0_1 ($a,$i) =                         if (($i >= $s))
743
715
 
                            then $a
744
716
 
                            else cb($a, $l[$i])
745
717
 
746
718
 
                        func $f0_2 ($a,$i) =                         if (($i >= $s))
747
719
 
                            then $a
748
720
 
                            else throw("List size exceeds 1")
749
721
 
750
722
 
                        $f0_2($f0_1($acc0, 0), 1)
751
723
 
                        }
752
724
 
                    if ((actions == actions))
753
725
 
                        then $Tuple2(nil, unit)
754
726
 
                        else throw("Strict value is not equal to itself.")
755
727
 
                    }
756
728
 
                else throw("Strict value is not equal to itself.")
757
729
 
            }
758
730
 
        else throw("Strict value is not equal to itself.")
759
731
 
    }
760
732
 
761
733
 
762
734
 
763
735
 
@Callable(i)
764
736
 
func isPoolOneTokenOperationsDisabledREADONLY (poolAddress) = {
765
737
 
    let poolConfig = getPoolConfig(poolAddress)
766
738
 
    let assetsInternal = $Tuple2(parseIntValue(poolConfig[idxIAmtAssetId]), parseIntValue(poolConfig[idxIPriceAssetId]))
767
739
 
    let poolOneTokenOperationsDisabled = valueOrElse(getBoolean(keyPoolOneTokenOperationsDisabled(assetsInternal)), false)
768
740
 
    let allPoolsOneTokenOperationsDisabled = valueOrElse(getBoolean(keyAllPoolsOneTokenOperationsDisabled()), false)
769
741
 
    $Tuple2(nil, if (allPoolsOneTokenOperationsDisabled)
770
742
 
        then true
771
743
 
        else poolOneTokenOperationsDisabled)
772
744
 
    }
773
745
 
774
746
 
775
747
 
776
748
 
@Callable(i)
777
749
 
func getInFeeREADONLY (poolAddress) = {
778
750
 
    let fee = intOrDefaultOrFallback(keyInFee(poolAddress), keyInFeeDefault(), 0)
779
751
 
    $Tuple2(nil, fee)
780
752
 
    }
781
753
 
782
754
 
783
755
 
784
756
 
@Callable(i)
785
757
 
func getOutFeeREADONLY (poolAddress) = {
786
758
 
    let fee = intOrDefaultOrFallback(keyOutFee(poolAddress), keyOutFeeDefault(), fraction(10, MULT8, 10000))
787
759
 
    $Tuple2(nil, fee)
788
760
 
    }
789
761
 
790
762
 
791
763
 
792
764
 
@Callable(i)
793
765
 
func getPoolStatusREADONLY (poolAddress) = {
794
766
 
    let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
795
767
 
    let amountAssetInternal = poolAssets[1]
796
768
 
    let priceAssetInternal = poolAssets[2]
797
769
 
    let cfg = split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
798
770
 
    $Tuple2(nil, parseIntValue(cfg[idxPoolStatus]))
799
771
 
    }
800
772
 
801
773
 
802
774
 
@Verifier(tx)
803
775
 
func verify () = {
804
776
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
805
777
 
        case pk: ByteVector => 
806
778
 
            pk
807
779
 
        case _: Unit => 
808
780
 
            tx.senderPublicKey
809
781
 
        case _ => 
810
782
 
            throw("Match error")
811
783
 
    }
812
784
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
813
785
 
    }
814
786
 

github/deemru/w8io/3ef1775 
119.70 ms ◑