tx · A5uVXFccvPooCaf31zcXRVHcboaJq2EXfthpDD6fUkgF

3N54be7eQeEt4amtgvApGgpFXd3qK3woBTE:  -0.03200000 Waves

2023.03.16 14:18 [2492509] smart account 3N54be7eQeEt4amtgvApGgpFXd3qK3woBTE > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "A5uVXFccvPooCaf31zcXRVHcboaJq2EXfthpDD6fUkgF",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1678965555152,
    "version": 2,
    "chainId": 84,
    "sender": "3N54be7eQeEt4amtgvApGgpFXd3qK3woBTE",
    "senderPublicKey": "3AmCTZMhyVJ6aQif32JBwAJHCqXMvytEognyyC3RmVDJ",
    "proofs": [
        "365tkwPboRbLWUf7qLewQCacvNJt8hDTBVcoA2K4wfYLgkximFTNMF1fGTx4skQSdtNPVR8ucNLu6LpvWPSAsj83"
    ],
    "script": "base64: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",
    "height": 2492509,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: AVZx7ZpsNz99CL4ExRtsV6uwwYB9F2q8fBKdSXZ8aYU2
Next: 7CyTi4crS7ygtJXGete89N78kXRMDKr2zvsPDumMyumA

Full: 

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