tx · 8GauiF72wi24yv4Zh9VAhvFcntCAsehQjHQjEk8MGxVT

3MoyY7JSaeScGuAX9zYEz8oJGmCTxT6ZXFT:  -0.03200000 Waves

2023.03.10 09:37 [2483619] smart account 3MoyY7JSaeScGuAX9zYEz8oJGmCTxT6ZXFT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8GauiF72wi24yv4Zh9VAhvFcntCAsehQjHQjEk8MGxVT",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1678430248936,
    "version": 1,
    "sender": "3MoyY7JSaeScGuAX9zYEz8oJGmCTxT6ZXFT",
    "senderPublicKey": "5a1aoVTAmt3S5Mng77UMBwNYwo6fs474DSf3KJRvg8Hg",
    "proofs": [
        "4QvEcohJHC2dMQKzcTZjUVppmTqRQYEM1CDrB9R2wFWehSUCbF5KHqudA6SzD7QZuWQSQsPPAkfgDNXcPVt7m66R"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2483619,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6x3UjL7Ym2YEAsP3rYhjtr9wPsMSSRvNPc2EoemmqMmR
Next: 6uav8APmaNRGpox4W6VXL7kxjN2CLoa9KH4NeDHP9Hda

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) = {
141141     let $t038253887 = assetsInternal
142142     let amountAssetInternal = $t038253887._1
143143     let priceAssetInternal = $t038253887._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)
865865 func poolExistsREADONLY (amountAssetId,priceAssetId) = $Tuple2(nil, poolExistsInternal(amountAssetId, priceAssetId))
866866 
867867 
868868 @Verifier(tx)
869869 func verify () = {
870870     let targetPublicKey =     match managerPublicKeyOrUnit() {
871871         case pk: ByteVector => 
872872             pk
873873         case _: Unit => 
874874             tx.senderPublicKey
875875         case _ => 
876876             throw("Match error")
877877     }
878878     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
879879     }
880880 
github/deemru/w8io/169f3d6 
79.17 ms ◑