tx · FGqGzctYGxs4ridN6cfqu9vkXuQiCcfxbSpMm8EceFLh

3MoyY7JSaeScGuAX9zYEz8oJGmCTxT6ZXFT:  -0.03200000 Waves

2023.03.14 17:25 [2489835] smart account 3MoyY7JSaeScGuAX9zYEz8oJGmCTxT6ZXFT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FGqGzctYGxs4ridN6cfqu9vkXuQiCcfxbSpMm8EceFLh",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1678804019034,
    "version": 2,
    "chainId": 84,
    "sender": "3MoyY7JSaeScGuAX9zYEz8oJGmCTxT6ZXFT",
    "senderPublicKey": "5a1aoVTAmt3S5Mng77UMBwNYwo6fs474DSf3KJRvg8Hg",
    "proofs": [
        "4FkyaFh8wxdstrRt5ZG2wB3nuGzPw1xyNkcNdfUX2FJmuv8uSipkpmhE1jpfW9ZJVfbj6WgftF1N1Jhp5ud1fyHN"
    ],
    "script": "base64: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",
    "height": 2489835,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: CMN8wfFREQeQbkyVZxj49yYAtByvgECFSF4B4FPK72Hh
Next: 6BZUgPdAUKK5zd1JxkwwEBkY1N5EtpPsCGFvHgWkmukj

Diff: 

OldNewDifferences
138138 
139139 
140140 func keyPoolOneTokenOperationsDisabled (assetsInternal) = {
141-    let $t038253887 = assetsInternal
142-    let amountAssetInternal = $t038253887._1
143-    let priceAssetInternal = $t038253887._2
141+    let $t037263788 = assetsInternal
142+    let amountAssetInternal = $t037263788._1
143+    let priceAssetInternal = $t037263788._2
144144     makeString(["%d%d%s", toString(amountAssetInternal), toString(priceAssetInternal), "oneTokenOperationsDisabled"], SEP)
145145     }
146146 
862862 
863863 
864864 @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)
865876 func poolExistsREADONLY (amountAssetId,priceAssetId) = $Tuple2(nil, poolExistsInternal(amountAssetId, priceAssetId))
866877 
867878 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SCALE8 = 8
55 
66 let MULT8 = 100000000
77 
88 let SCALE18 = 18
99 
1010 let MULT18 = toBigInt(1000000000000000000)
1111 
1212 let POOLWEIGHTMULT = MULT8
1313 
1414 let GWXvirtualPOOL = "GWXvirtualPOOL"
1515 
1616 let labelPoolsLp = "POOLS_LP"
1717 
1818 let defaultSpread = 2000000
1919 
2020 let wavesString = "WAVES"
2121 
2222 let decimalsMultPrice = ((100 * 1000) * 1000)
2323 
2424 let SEP = "__"
2525 
2626 let EMPTY = ""
2727 
2828 let PoolActive = 1
2929 
3030 let PoolPutDisabled = 2
3131 
3232 let PoolMatcherDisabled = 3
3333 
3434 let PoolShutdown = 4
3535 
3636 let idxInternalAssetId = 1
3737 
3838 let idxResutActions = 2
3939 
4040 let idxIfAssetIdCalculationPerformed = 3
4141 
4242 let idxPoolAddress = 1
4343 
4444 let idxPoolStatus = 2
4545 
4646 let idxPoolLPAssetId = 3
4747 
4848 let idxAmtAssetId = 4
4949 
5050 let idxPriceAssetId = 5
5151 
5252 let idxAmtAssetDcm = 6
5353 
5454 let idxPriceAssetDcm = 7
5555 
5656 let idxIAmtAssetId = 8
5757 
5858 let idxIPriceAssetId = 9
5959 
6060 let idxLPAssetDcm = 10
6161 
6262 let idxPoolType = 11
6363 
6464 let poolLabelWxEmission = "WX_EMISSION"
6565 
6666 let validPoolLabels = [poolLabelWxEmission]
6767 
6868 func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
6969 
7070 
7171 func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
7272 
7373 
7474 func keyAllowedLpStableAddonScriptHash () = "%s__allowedLpStableAddonScriptHash"
7575 
7676 
7777 func swapContract () = "%s__swapContract"
7878 
7979 
8080 func keyFactoryConfig () = "%s__factoryConfig"
8181 
8282 
8383 func keyLpTokensList () = "%s__lpTokensList"
8484 
8585 
8686 func keyPoolScriptHash () = "%s%s__pool__scriptHash"
8787 
8888 
8989 func keyMatcherPub () = "%s%s__matcher__publicKey"
9090 
9191 
9292 func keyLegacyFactoryContract () = "%s__legacyFactoryContract"
9393 
9494 
9595 func keyLegacyPools () = "%s__legacyPools"
9696 
9797 
9898 func keyManagerPublicKey () = "%s__managerPublicKey"
9999 
100100 
101101 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
102102 
103103 
104104 func keyAdminPubKeys () = "%s__adminPubKeys"
105105 
106106 
107107 func keyAssetsStoreContract () = "%s__assetsStoreContract"
108108 
109109 
110110 func keyVotingEmissionContract () = "%s__votingEmissionContract"
111111 
112112 
113113 func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
114114 
115115 
116116 func keyPriceDecimals () = "%s__priceDecimals"
117117 
118118 
119119 func keyAllPoolsShutdown () = "%s__shutdown"
120120 
121121 
122122 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
123123 
124124 
125125 func keyPoolToWeight (poolAddress) = ("%s%s__poolWeight__" + poolAddress)
126126 
127127 
128128 func keyPoolToWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
129129 
130130 
131131 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
132132 
133133 
134134 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
135135 
136136 
137137 func keyPoolConfig (amountAssetInternal,priceAssetInternal) = (((("%d%d%s__" + amountAssetInternal) + "__") + priceAssetInternal) + "__config")
138138 
139139 
140140 func keyPoolOneTokenOperationsDisabled (assetsInternal) = {
141-    let $t038253887 = assetsInternal
142-    let amountAssetInternal = $t038253887._1
143-    let priceAssetInternal = $t038253887._2
141+    let $t037263788 = assetsInternal
142+    let amountAssetInternal = $t037263788._1
143+    let priceAssetInternal = $t037263788._2
144144     makeString(["%d%d%s", toString(amountAssetInternal), toString(priceAssetInternal), "oneTokenOperationsDisabled"], SEP)
145145     }
146146 
147147 
148148 func keyAllPoolsOneTokenOperationsDisabled () = makeString(["%s", "oneTokenOperationsDisabled"], SEP)
149149 
150150 
151151 func keyMappingLpAssetToPoolAssets (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2Pool")
152152 
153153 
154154 func keyMappingPoolAssetsToLpasset (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + internalAmountAssetIdStr) + "__") + internalPriceAssetIdStr) + "__mappings__PoolAssets2LpAsset")
155155 
156156 
157157 func keyPoolSpread (poolAddress) = ("%s%s__spread__" + poolAddress)
158158 
159159 
160160 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
161161 
162162 
163163 func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
164164 
165165 
166166 func keyMappingPoolContractToLPAsset (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
167167 
168168 
169169 func keyMappingPoolLPAssetToPoolContractAddress (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2PoolContract")
170170 
171171 
172172 func keyWxEmission (amountAssetId,priceAssetId) = ((("%s%s%s__wxEmission__" + amountAssetId) + "__") + priceAssetId)
173173 
174174 
175175 func keyInFee (poolAddress) = ("%s%s__inFee__" + poolAddress)
176176 
177177 
178178 func keyInFeeDefault () = "%s__inFeeDefault"
179179 
180180 
181181 func keyOutFee (poolAddress) = ("%s%s__outFee__" + poolAddress)
182182 
183183 
184184 func keyOutFeeDefault () = "%s__outFeeDefault"
185185 
186186 
187187 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
188188 
189189 
190190 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
191191 
192192 
193193 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
194194 
195195 
196196 func parseAssetId (input) = if ((input == wavesString))
197197     then unit
198198     else fromBase58String(input)
199199 
200200 
201201 let IdxFactoryCfgStakingDapp = 1
202202 
203203 let IdxFactoryCfgBoostingDapp = 2
204204 
205205 let IdxFactoryCfgIdoDapp = 3
206206 
207207 let IdxFactoryCfgTeamDapp = 4
208208 
209209 let IdxFactoryCfgEmissionDapp = 5
210210 
211211 let IdxFactoryCfgRestDapp = 6
212212 
213213 let IdxFactoryCfgSlippageDapp = 7
214214 
215215 let IdxFactoryCfgDaoDapp = 8
216216 
217217 let IdxFactoryCfgMarketingDapp = 9
218218 
219219 let IdxFactoryCfgGwxRewardDapp = 10
220220 
221221 let IdxFactoryCfgBirdsDapp = 11
222222 
223223 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
224224 
225225 
226226 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
227227 
228228 
229229 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
230230 
231231 
232232 func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
233233 
234234 
235235 func getPriceAssets () = match getString(keyPriceAssets()) {
236236     case s: String => 
237237         if ((size(s) == 0))
238238             then nil
239239             else split(s, SEP)
240240     case _ => 
241241         nil
242242 }
243243 
244244 
245245 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
246246     case s: String => 
247247         fromBase58String(s)
248248     case _: Unit => 
249249         unit
250250     case _ => 
251251         throw("Match error")
252252 }
253253 
254254 
255255 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
256256     case s: String => 
257257         fromBase58String(s)
258258     case _: Unit => 
259259         unit
260260     case _ => 
261261         throw("Match error")
262262 }
263263 
264264 
265265 let permissionDeniedError = throw("Permission denied")
266266 
267267 let testError = throw("Test error here")
268268 
269269 func mustThis (i) = if ((i.caller == this))
270270     then true
271271     else permissionDeniedError
272272 
273273 
274274 func mustManager (i) = match managerPublicKeyOrUnit() {
275275     case pk: ByteVector => 
276276         if ((i.callerPublicKey == pk))
277277             then true
278278             else permissionDeniedError
279279     case _: Unit => 
280280         mustThis(i)
281281     case _ => 
282282         throw("Match error")
283283 }
284284 
285285 
286286 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)
287287 
288288 
289289 func dataFactoryCfg (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract) = makeString(["%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract], SEP)
290290 
291291 
292292 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)
293293 
294294 
295295 func dataMappingPoolAssets (internalAmountAssetStr,internalPriceAssetStr) = makeString(["%d%d", toString(internalAmountAssetStr), toString(internalPriceAssetStr)], SEP)
296296 
297297 
298298 func getPoolConfig (poolAddress) = {
299299     let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
300300     let amountAssetInternal = poolAssets[1]
301301     let priceAssetInternal = poolAssets[2]
302302     split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
303303     }
304304 
305305 
306306 func getInternalAssetIdOrCreate (assetIdStr,incrementor) = {
307307     let internalAssetId = valueOrElse(getInteger(this, keyMappingsBaseAsset2internalId(assetIdStr)), 0)
308308     let currentIndexOfInternalId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
309309     let result = if ((internalAssetId == 0))
310310         then {
311311             let newInternalAssetId = (currentIndexOfInternalId + incrementor)
312312             $Tuple3(newInternalAssetId, [IntegerEntry(keyNextInternalAssetId(), newInternalAssetId), IntegerEntry(keyMappingsBaseAsset2internalId(assetIdStr), newInternalAssetId), StringEntry(keyMappingsInternal2baseAssetId(newInternalAssetId), assetIdStr)], true)
313313             }
314314         else $Tuple3(internalAssetId, nil, false)
315315     result
316316     }
317317 
318318 
319319 func mustAdmin (i) = {
320320     let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
321321     if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
322322         then true
323323         else {
324324             let isManager = mustManager(i)
325325             if ((isManager == isManager))
326326                 then true
327327                 else throw("Strict value is not equal to itself.")
328328             }
329329     }
330330 
331331 
332332 func intOrDefaultOrFallback (key,keyDefault,valueFallback) = valueOrElse(getInteger(this, key), valueOrElse(getInteger(this, keyDefault), valueFallback))
333333 
334334 
335335 func poolExistsInternal (amountAssetId,priceAssetId) = {
336336     let amountAssetInternal = getInteger(keyMappingsBaseAsset2internalId(amountAssetId))
337337     let priceAssetInternal = getInteger(keyMappingsBaseAsset2internalId(priceAssetId))
338338     if (if ((amountAssetInternal == unit))
339339         then true
340340         else (priceAssetInternal == unit))
341341         then false
342342         else {
343343             let amAs = toString(value(amountAssetInternal))
344344             let prAs = toString(value(priceAssetInternal))
345345             let cfg = getString(keyPoolConfig(amAs, prAs))
346346             let cfgReverse = getString(keyPoolConfig(prAs, amAs))
347347             let exists = if ((cfg != unit))
348348                 then true
349349                 else (cfgReverse != unit)
350350             exists
351351             }
352352     }
353353 
354354 
355355 @Callable(i)
356356 func getSwapContractREADONLY () = $Tuple2(nil, getStringOrFail(swapContract()))
357357 
358358 
359359 
360360 @Callable(i)
361361 func getLpAssetFromPoolAssetsREADONLY (asset1,asset2) = if (if ((asset1 == "8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS"))
362362     then (asset2 == "WAVES")
363363     else false)
364364     then $Tuple2(nil, unit)
365365     else {
366366         let assetNum1 = value(getInteger(this, keyMappingsBaseAsset2internalId(asset1)))
367367         let assetNum2 = value(getInteger(this, keyMappingsBaseAsset2internalId(asset2)))
368368         let ee = getString(this, keyMappingPoolAssetsToLpasset(toString(assetNum1), toString(assetNum2)))
369369         let res = if ((ee == unit))
370370             then unit
371371             else drop(value(ee), 4)
372372         $Tuple2(nil, res)
373373         }
374374 
375375 
376376 
377377 @Callable(i)
378378 func getPoolAddressFromLpAssetREADONLY (lp) = $Tuple2(nil, valueOrElse(getString(this, keyMappingPoolLPAssetToPoolContractAddress(lp)), ""))
379379 
380380 
381381 
382382 @Callable(i)
383383 func constructor (stakingContract,boostingContract,idoContract,teamContract,emissionContract,restContract,slpipageContract,priceDecimals) = {
384384     let checkCaller = mustManager(i)
385385     if ((checkCaller == checkCaller))
386386         then [StringEntry(keyFactoryConfig(), dataFactoryCfg(stakingContract, boostingContract, idoContract, teamContract, emissionContract, restContract, slpipageContract)), IntegerEntry(keyPriceDecimals(), priceDecimals)]
387387         else throw("Strict value is not equal to itself.")
388388     }
389389 
390390 
391391 
392392 @Callable(i)
393393 func constructorV2 (mathcherPub58Str) = {
394394     let checkCaller = mustManager(i)
395395     if ((checkCaller == checkCaller))
396396         then {
397397             let mathcerPub = addressFromPublicKey(fromBase58String(mathcherPub58Str))
398398             if ((mathcerPub == mathcerPub))
399399                 then [StringEntry(keyMatcherPub(), mathcherPub58Str)]
400400                 else throw("Strict value is not equal to itself.")
401401             }
402402         else throw("Strict value is not equal to itself.")
403403     }
404404 
405405 
406406 
407407 @Callable(i)
408408 func constructorV3 (daoContract,marketingContract,gwxRewardsContract,birdsContract) = {
409409     let checkCaller = mustManager(i)
410410     if ((checkCaller == checkCaller))
411411         then {
412412             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
413413 [StringEntry(keyFactoryConfig(), dataFactoryCfgV3(factoryCfg[1], factoryCfg[2], factoryCfg[3], factoryCfg[4], factoryCfg[5], factoryCfg[6], factoryCfg[7], daoContract, marketingContract, gwxRewardsContract, birdsContract))]
414414             }
415415         else throw("Strict value is not equal to itself.")
416416     }
417417 
418418 
419419 
420420 @Callable(i)
421421 func constructorV4 (legacyFactoryContract,legacyPools) = {
422422     let checkCaller = mustManager(i)
423423     if ((checkCaller == checkCaller))
424424         then [StringEntry(keyLegacyFactoryContract(), legacyFactoryContract), StringEntry(keyLegacyPools(), makeString(legacyPools, SEP))]
425425         else throw("Strict value is not equal to itself.")
426426     }
427427 
428428 
429429 
430430 @Callable(i)
431431 func constructorV5 (assetsStoreContract) = {
432432     let checkCaller = mustManager(i)
433433     if ((checkCaller == checkCaller))
434434         then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
435435         else throw("Strict value is not equal to itself.")
436436     }
437437 
438438 
439439 
440440 @Callable(i)
441441 func constructorV6 (votingEmissionContract,priceAssets) = {
442442     let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
443443         then true
444444         else "invalid voting emission contract address"]
445445     if ((cheks == cheks))
446446         then [StringEntry(keyVotingEmissionContract(), votingEmissionContract), StringEntry(keyPriceAssets(), makeString(priceAssets, SEP))]
447447         else throw("Strict value is not equal to itself.")
448448     }
449449 
450450 
451451 
452452 @Callable(i)
453453 func setManager (pendingManagerPublicKey) = {
454454     let checkCaller = mustManager(i)
455455     if ((checkCaller == checkCaller))
456456         then {
457457             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
458458             if ((checkManagerPublicKey == checkManagerPublicKey))
459459                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
460460                 else throw("Strict value is not equal to itself.")
461461             }
462462         else throw("Strict value is not equal to itself.")
463463     }
464464 
465465 
466466 
467467 @Callable(i)
468468 func confirmManager () = {
469469     let pm = pendingManagerPublicKeyOrUnit()
470470     let hasPM = if (isDefined(pm))
471471         then true
472472         else throw("No pending manager")
473473     if ((hasPM == hasPM))
474474         then {
475475             let checkPM = if ((i.callerPublicKey == value(pm)))
476476                 then true
477477                 else throw("You are not pending manager")
478478             if ((checkPM == checkPM))
479479                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
480480                 else throw("Strict value is not equal to itself.")
481481             }
482482         else throw("Strict value is not equal to itself.")
483483     }
484484 
485485 
486486 
487487 @Callable(i)
488488 func setAdmins (adminPubKeys) = {
489489     let checkCaller = mustManager(i)
490490     if ((checkCaller == checkCaller))
491491         then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
492492         else throw("Strict value is not equal to itself.")
493493     }
494494 
495495 
496496 
497497 @Callable(i)
498498 func activateNewPool (poolAddress,amountAssetStr,priceAssetStr,lpAssetName,lpAssetDescr,poolWeight,poolType,logo) = {
499499     let checkCaller = mustAdmin(i)
500500     if ((checkCaller == checkCaller))
501501         then if (isDefined(getString(keyMappingPoolContractAddressToPoolAssets(poolAddress))))
502502             then throw((("Pool address " + poolAddress) + " already registered."))
503503             else {
504504                 let internalAmountAssetData = getInternalAssetIdOrCreate(amountAssetStr, 1)
505505                 let internalAmountAssetId = internalAmountAssetData._1
506506                 let internalPriceAssetData = getInternalAssetIdOrCreate(priceAssetStr, if (internalAmountAssetData._3)
507507                     then 2
508508                     else 1)
509509                 let internalPriceAssetId = internalPriceAssetData._1
510510                 let poolAccountScriptHash = valueOrErrorMessage(scriptHash(addressFromStringValue(poolAddress)), ("No script has been found on pool account " + poolAddress))
511511                 let ethalonPoolAccountScriptHash = getBinaryValue(keyPoolScriptHash())
512512                 let poolExists = poolExistsInternal(amountAssetStr, priceAssetStr)
513513                 if (poolExists)
514514                     then throw((((("Pool " + amountAssetStr) + "/") + priceAssetStr) + " has already been activated."))
515515                     else {
516516                         let poolConfigValue = value(getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId))))
517517                         let amountAssetsDecimals = if ((amountAssetStr == "WAVES"))
518518                             then decimalsMultPrice
519519                             else pow(10, 0, value(assetInfo(fromBase58String(amountAssetStr))).decimals, 0, 0, DOWN)
520520                         let priceAssetsDecimals = if ((priceAssetStr == "WAVES"))
521521                             then decimalsMultPrice
522522                             else pow(10, 0, value(assetInfo(fromBase58String(priceAssetStr))).decimals, 0, 0, DOWN)
523523                         let lpAssetIssueAction = Issue(lpAssetName, lpAssetDescr, 1, 8, true)
524524                         let lpAssetId = calculateAssetId(lpAssetIssueAction)
525525                         let lpAssetIdStr = toBase58String(lpAssetId)
526526                         let poolActivateInvokeResult = invoke(addressFromStringValue(poolAddress), "activate", [amountAssetStr, priceAssetStr], nil)
527527                         if ((poolActivateInvokeResult == poolActivateInvokeResult))
528528                             then if ((poolActivateInvokeResult != "success"))
529529                                 then throw("Pool initialisation error happened.")
530530                                 else {
531531                                     let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract()))
532532                                     let createOrUpdateLpAssetInv = invoke(assetsStoreContract, "createOrUpdate", [lpAssetIdStr, lpAssetName, false], nil)
533533                                     if ((createOrUpdateLpAssetInv == createOrUpdateLpAssetInv))
534534                                         then {
535535                                             let addPoolsLpLabelInv = invoke(assetsStoreContract, "addLabel", [lpAssetIdStr, labelPoolsLp], nil)
536536                                             if ((addPoolsLpLabelInv == addPoolsLpLabelInv))
537537                                                 then {
538538                                                     let setLogoInv = invoke(assetsStoreContract, "setLogo", [lpAssetIdStr, logo], nil)
539539                                                     if ((setLogoInv == setLogoInv))
540540                                                         then {
541541                                                             let addAssetsLinkInv = invoke(assetsStoreContract, "addAssetsLink", [amountAssetStr, priceAssetStr, lpAssetIdStr], nil)
542542                                                             if ((addAssetsLinkInv == addAssetsLinkInv))
543543                                                                 then {
544544                                                                     let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
545545                                                                     if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
546546                                                                         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)
547547                                                                         else throw("Strict value is not equal to itself.")
548548                                                                     }
549549                                                                 else throw("Strict value is not equal to itself.")
550550                                                             }
551551                                                         else throw("Strict value is not equal to itself.")
552552                                                     }
553553                                                 else throw("Strict value is not equal to itself.")
554554                                             }
555555                                         else throw("Strict value is not equal to itself.")
556556                                     }
557557                             else throw("Strict value is not equal to itself.")
558558                         }
559559                 }
560560         else throw("Strict value is not equal to itself.")
561561     }
562562 
563563 
564564 
565565 @Callable(i)
566566 func managePool (poolAddress,newStatus) = {
567567     let checkCaller = mustManager(i)
568568     if ((checkCaller == checkCaller))
569569         then {
570570             let poolConfig = getPoolConfig(poolAddress)
571571             let poolStatus = poolConfig[idxPoolStatus]
572572             let lpAssetIdStr = poolConfig[idxPoolLPAssetId]
573573             let amountAssetStr = poolConfig[idxAmtAssetId]
574574             let priceAssetStr = poolConfig[idxPriceAssetId]
575575             let amountAssetsDecimals = parseIntValue(poolConfig[idxAmtAssetDcm])
576576             let priceAssetsDecimals = parseIntValue(poolConfig[idxPriceAssetDcm])
577577             let internalAmountAssetId = parseIntValue(poolConfig[idxIAmtAssetId])
578578             let internalPriceAssetId = parseIntValue(poolConfig[idxIPriceAssetId])
579579             let lpAssetDcm = parseIntValue(poolConfig[idxLPAssetDcm])
580580             let poolType = poolConfig[idxPoolType]
581581 [StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(newStatus), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, lpAssetDcm, poolType))]
582582             }
583583         else throw("Strict value is not equal to itself.")
584584     }
585585 
586586 
587587 
588588 @Callable(i)
589589 func emit (amountToEmit) = {
590590     let caller = i.caller
591591     let originCaller = i.originCaller
592592     let lpAssetRequested = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
593593     let lpAsset = fromBase58String(lpAssetRequested)
594594     let legacyPools = split(valueOrElse(getString(keyLegacyPools()), EMPTY), SEP)
595595     let legacyFactoryContract = addressFromStringValue(valueOrErrorMessage(getString(keyLegacyFactoryContract()), "Legacy factory contract does not exists."))
596596     if ((0 >= amountToEmit))
597597         then nil
598598         else if (containsElement(legacyPools, toString(caller)))
599599             then $Tuple2(nil, legacyFactoryContract)
600600             else $Tuple2([Reissue(lpAsset, amountToEmit, true), ScriptTransfer(i.caller, amountToEmit, lpAsset)], "success")
601601     }
602602 
603603 
604604 
605605 @Callable(i)
606606 func burn (amountToBurn) = {
607607     let caller = i.caller
608608     let originCaller = i.originCaller
609609     let payment = value(i.payments[0])
610610     let paymentAmount = value(payment.amount)
611611     let inAmountAssetId = toBase58String(value(payment.assetId))
612612     let lpAssetRequestedForBurning = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
613613     if ((inAmountAssetId != lpAssetRequestedForBurning))
614614         then throw("Invalid asset passed.")
615615         else if ((amountToBurn != paymentAmount))
616616             then throw("Invalid amount passed.")
617617             else {
618618                 let lpAsset = fromBase58String(lpAssetRequestedForBurning)
619619                 $Tuple2([Burn(lpAsset, amountToBurn)], "success")
620620                 }
621621     }
622622 
623623 
624624 
625625 @Callable(i)
626626 func modifyWeight (lpAssetId,share) = {
627627     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
628628         then true
629629         else mustManager(i)
630630     if ((checkCaller == checkCaller))
631631         then {
632632             let poolContractAddress = getStringOrFail(keyMappingPoolLPAssetToPoolContractAddress(lpAssetId))
633633             let poolWeightKey = keyPoolToWeight(poolContractAddress)
634634             let gwxWeightKey = keyPoolToWeight(GWXvirtualPOOL)
635635             let gwxWeight = valueOrElse(getInteger(gwxWeightKey), 0)
636636             let poolWeight = valueOrElse(getInteger(poolWeightKey), 0)
637637             let poolWeightNew = share
638638             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
639639             let stakingContract = getStakingAddressOrFail(factoryCfg)
640640             let onModifyWeightInv = invoke(stakingContract, "onModifyWeight", [lpAssetId, poolContractAddress], nil)
641641             if ((onModifyWeightInv == onModifyWeightInv))
642642                 then {
643643                     let gwxVirtualPoolActions = if ((gwxWeight == 0))
644644                         then nil
645645                         else [IntegerEntry(gwxWeightKey, 0)]
646646                     let poolWeightHistoryKey = keyPoolToWeightHistory(poolContractAddress, 0)
647647                     let poolWeightHistoryOrUnit = getInteger(poolWeightHistoryKey)
648648                     let poolWeightHistoryActions = if ((poolWeightHistoryOrUnit == unit))
649649                         then nil
650650                         else [DeleteEntry(poolWeightHistoryKey)]
651651                     (([IntegerEntry(poolWeightKey, poolWeightNew)] ++ gwxVirtualPoolActions) ++ poolWeightHistoryActions)
652652                     }
653653                 else throw("Strict value is not equal to itself.")
654654             }
655655         else throw("Strict value is not equal to itself.")
656656     }
657657 
658658 
659659 
660660 @Callable(i)
661661 func modifyWeights (btcPoolAddress,ethPoolAddress,ethBtcPoolAddress,usdcUsdtPoolAddress) = {
662662     let checkCaller = mustManager(i)
663663     if ((checkCaller == checkCaller))
664664         then {
665665             let ethBtcWeightNew = ((5 * POOLWEIGHTMULT) / 100)
666666             let usdcUsdtWeightNew = ((5 * POOLWEIGHTMULT) / 100)
667667             let weightDecrement = ((5 * POOLWEIGHTMULT) / 100)
668668             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
669669             let stakingDapp = getStakingAddressOrFail(factoryCfg)
670670             let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
671671             let btcWeightKEY = keyPoolToWeight(btcPoolAddress)
672672             let ethWeightKEY = keyPoolToWeight(ethPoolAddress)
673673             let ethBtcWeightKEY = keyPoolToWeight(ethBtcPoolAddress)
674674             let usdcUsdtWeightKEY = keyPoolToWeight(usdcUsdtPoolAddress)
675675             let btcWeight = getIntOrFail(btcWeightKEY)
676676             let ethWeight = getIntOrFail(ethWeightKEY)
677677             let btcWeightNew = (btcWeight - weightDecrement)
678678             let ethWeightNew = (ethWeight - weightDecrement)
679679             if ((0 >= btcWeightNew))
680680                 then throw(("invalid btcWeightNew: " + toString(btcWeightNew)))
681681                 else if ((0 >= ethWeightNew))
682682                     then throw(("invalid ethWeightNew: " + toString(ethWeightNew)))
683683                     else {
684684                         let btcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(btcPoolAddress))
685685                         let ethLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethPoolAddress))
686686                         let ethBtcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethBtcPoolAddress))
687687                         let usdcUsdtLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(usdcUsdtPoolAddress))
688688                         let onModifyWeightBtc = invoke(stakingDapp, "onModifyWeight", [btcLpAssetIdStr, btcPoolAddress], nil)
689689                         if ((onModifyWeightBtc == onModifyWeightBtc))
690690                             then {
691691                                 let onModifyWeightEth = invoke(stakingDapp, "onModifyWeight", [ethLpAssetIdStr, ethPoolAddress], nil)
692692                                 if ((onModifyWeightEth == onModifyWeightEth))
693693                                     then {
694694                                         let onModifyWeightEthBtc = invoke(stakingDapp, "onModifyWeight", [ethBtcLpAssetIdStr, ethBtcPoolAddress], nil)
695695                                         if ((onModifyWeightEthBtc == onModifyWeightEthBtc))
696696                                             then {
697697                                                 let onModifyWeightUsdcUsdt = invoke(stakingDapp, "onModifyWeight", [usdcUsdtLpAssetIdStr, usdcUsdtPoolAddress], nil)
698698                                                 if ((onModifyWeightUsdcUsdt == onModifyWeightUsdcUsdt))
699699                                                     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)]
700700                                                     else throw("Strict value is not equal to itself.")
701701                                                 }
702702                                             else throw("Strict value is not equal to itself.")
703703                                         }
704704                                     else throw("Strict value is not equal to itself.")
705705                                 }
706706                             else throw("Strict value is not equal to itself.")
707707                         }
708708             }
709709         else throw("Strict value is not equal to itself.")
710710     }
711711 
712712 
713713 
714714 @Callable(i)
715715 func checkWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
716716     let haveLabel =     match getBoolean(keyWxEmission(amountAssetId, priceAssetId)) {
717717         case b: Boolean => 
718718             b
719719         case _ => 
720720             false
721721     }
722722     $Tuple2(nil, haveLabel)
723723     }
724724 
725725 
726726 
727727 @Callable(i)
728728 func setWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
729729     let checkCaller = mustAdmin(i)
730730     if ((checkCaller == checkCaller))
731731         then $Tuple2([BooleanEntry(keyWxEmission(amountAssetId, priceAssetId), true)], unit)
732732         else throw("Strict value is not equal to itself.")
733733     }
734734 
735735 
736736 
737737 @Callable(i)
738738 func deleteWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
739739     let checkCaller = if (mustThis(i))
740740         then true
741741         else mustAdmin(i)
742742     if ((checkCaller == checkCaller))
743743         then $Tuple2([DeleteEntry(keyWxEmission(amountAssetId, priceAssetId))], unit)
744744         else throw("Strict value is not equal to itself.")
745745     }
746746 
747747 
748748 
749749 @Callable(i)
750750 func onVerificationLoss (assetId) = {
751751     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyAssetsStoreContract()), "")))
752752         then true
753753         else mustManager(i)
754754     if ((checkCaller == checkCaller))
755755         then {
756756             let priceAssets = getPriceAssets()
757757             let checkPriceAssetsSize = if ((size(priceAssets) > 0))
758758                 then true
759759                 else throw("invalid price assets")
760760             if ((checkPriceAssetsSize == checkPriceAssetsSize))
761761                 then {
762762                     func cb (acc,priceAsset) =                     {
763763                         let r = invoke(this, "deleteWxEmissionPoolLabel", [assetId, priceAsset], nil)
764764                         if ((r == r))
765765                             then unit
766766                             else throw("Strict value is not equal to itself.")
767767                         }
768768 
769769                     let actions = {
770770                         let $l = priceAssets
771771                         let $s = size($l)
772772                         let $acc0 = unit
773773                         func $f0_1 ($a,$i) =                         if (($i >= $s))
774774                             then $a
775775                             else cb($a, $l[$i])
776776 
777777                         func $f0_2 ($a,$i) =                         if (($i >= $s))
778778                             then $a
779779                             else throw("List size exceeds 2")
780780 
781781                         $f0_2($f0_1($f0_1($acc0, 0), 1), 2)
782782                         }
783783                     if ((actions == actions))
784784                         then $Tuple2(nil, unit)
785785                         else throw("Strict value is not equal to itself.")
786786                     }
787787                 else throw("Strict value is not equal to itself.")
788788             }
789789         else throw("Strict value is not equal to itself.")
790790     }
791791 
792792 
793793 
794794 @Callable(i)
795795 func isPoolOneTokenOperationsDisabledREADONLY (poolAddress) = {
796796     let poolConfig = getPoolConfig(poolAddress)
797797     let assetsInternal = $Tuple2(parseIntValue(poolConfig[idxIAmtAssetId]), parseIntValue(poolConfig[idxIPriceAssetId]))
798798     let poolOneTokenOperationsDisabled = valueOrElse(getBoolean(keyPoolOneTokenOperationsDisabled(assetsInternal)), false)
799799     let allPoolsOneTokenOperationsDisabled = valueOrElse(getBoolean(keyAllPoolsOneTokenOperationsDisabled()), false)
800800     $Tuple2(nil, if (allPoolsOneTokenOperationsDisabled)
801801         then true
802802         else poolOneTokenOperationsDisabled)
803803     }
804804 
805805 
806806 
807807 @Callable(i)
808808 func getInFeeREADONLY (poolAddress) = {
809809     let fee = intOrDefaultOrFallback(keyInFee(poolAddress), keyInFeeDefault(), 0)
810810     $Tuple2(nil, fee)
811811     }
812812 
813813 
814814 
815815 @Callable(i)
816816 func getOutFeeREADONLY (poolAddress) = {
817817     let fee = intOrDefaultOrFallback(keyOutFee(poolAddress), keyOutFeeDefault(), fraction(10, MULT8, 10000))
818818     $Tuple2(nil, fee)
819819     }
820820 
821821 
822822 
823823 @Callable(i)
824824 func poolInfoREADONLY (amountAssetIdStr,priceAssetIdStr) = {
825825     let amountAssetInternalIdOption = getInteger(this, keyMappingsBaseAsset2internalId(amountAssetIdStr))
826826     let priceAssetInternalIdOption = getInteger(this, keyMappingsBaseAsset2internalId(priceAssetIdStr))
827827     let poolContractAddressOption = getString(this, keyMappingPoolAssetsToPoolContractAddress(value(amountAssetInternalIdOption), value(priceAssetInternalIdOption)))
828828     let lpAssetIdOption = getString(this, keyMappingPoolContractToLPAsset(value(poolContractAddressOption)))
829829     let poolExists = if (if (isDefined(amountAssetInternalIdOption))
830830         then isDefined(priceAssetInternalIdOption)
831831         else false)
832832         then isDefined(poolContractAddressOption)
833833         else false
834834     let poolInfo = if (poolExists)
835835         then $Tuple2(addressFromStringValue(value(poolContractAddressOption)), parseAssetId(value(lpAssetIdOption)))
836836         else unit
837837     $Tuple2(nil, poolInfo)
838838     }
839839 
840840 
841841 
842842 @Callable(i)
843843 func getPoolStatusREADONLY (poolAddress) = {
844844     let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
845845     let amountAssetInternal = poolAssets[1]
846846     let priceAssetInternal = poolAssets[2]
847847     let cfg = split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
848848     $Tuple2(nil, parseIntValue(cfg[idxPoolStatus]))
849849     }
850850 
851851 
852852 
853853 @Callable(i)
854854 func getPoolConfigREADONLY (poolAddress) = {
855855     let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
856856     let amountAssetInternal = poolAssets[1]
857857     let priceAssetInternal = poolAssets[2]
858858     let cfg = split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
859859     $Tuple2(nil, cfg)
860860     }
861861 
862862 
863863 
864864 @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)
865876 func poolExistsREADONLY (amountAssetId,priceAssetId) = $Tuple2(nil, poolExistsInternal(amountAssetId, priceAssetId))
866877 
867878 
868879 @Verifier(tx)
869880 func verify () = {
870881     let targetPublicKey =     match managerPublicKeyOrUnit() {
871882         case pk: ByteVector => 
872883             pk
873884         case _: Unit => 
874885             tx.senderPublicKey
875886         case _ => 
876887             throw("Match error")
877888     }
878889     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
879890     }
880891 
github/deemru/w8io/873ac7e 
255.85 ms ◑