tx · 6SexXF7wVWnbysTMdDEj1CrFUSPeksDo4rUHmzKZmHeK

3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai:  -0.03400000 Waves

2022.06.23 13:38 [2108948] smart account 3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6SexXF7wVWnbysTMdDEj1CrFUSPeksDo4rUHmzKZmHeK",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1655980789054,
    "version": 1,
    "sender": "3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai",
    "senderPublicKey": "2JEaBjtjvMoNGKZmL9QxYefa1VkMJM3vMW8rNvTs9R2H",
    "proofs": [
        "47jbmC1JrfmdG8wrtaepBEzkyTxhXX7ayhMgzYxcfvcgWEj9GdKVwHkAsBMmWaP79ZDiv9xz8L8AGQCZtx3L7oDq"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2108948,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: HXwuH21ULyFcomUMquEtcPfHjeoXALnPqdLUGQm9Asyh
Next: Acb628tFNpbLdqj9LAPNSVstUuLXisis8ti7TzPXo4Ln

Diff: 

OldNewDifferences
9494 func keyVotingEmissionContract () = "%s__votingEmissionContract"
9595 
9696 
97+func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
98+
99+
97100 func keyPriceDecimals () = "%s__priceDecimals"
98101 
99102 
180183 
181184 
182185 func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
186+
187+
188+func getPriceAssets () = match getString(keyPriceAssets()) {
189+    case s: String => 
190+        if ((size(s) == 0))
191+            then nil
192+            else split(s, SEP)
193+    case _ => 
194+        nil
195+}
183196 
184197 
185198 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
332345 
333346 
334347 @Callable(i)
335-func constructorV6 (votingEmissionContract) = {
348+func constructorV6 (votingEmissionContract,priceAssets) = {
336349     let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
337350         then true
338351         else "invalid voting emission contract address"]
339352     if ((cheks == cheks))
340-        then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
353+        then [StringEntry(keyVotingEmissionContract(), votingEmissionContract), StringEntry(keyPriceAssets(), makeString(priceAssets, SEP))]
341354         else throw("Strict value is not equal to itself.")
342355     }
343356 
626639     }
627640 
628641 
642+
643+@Callable(i)
644+func onVerificationLoss (assetId) = {
645+    let checkCaller = mustAdmin(i)
646+    if ((checkCaller == checkCaller))
647+        then {
648+            let priceAssets = getPriceAssets()
649+            let checkPriceAssetsSize = if ((size(priceAssets) > 0))
650+                then true
651+                else throw("invalid price assets")
652+            if ((checkPriceAssetsSize == checkPriceAssetsSize))
653+                then {
654+                    func cb (acc,priceAsset) =                     {
655+                        let r = invoke(this, "deleteWxEmissionPoolLabel", [assetId, priceAsset], nil)
656+                        if ((r == r))
657+                            then unit
658+                            else throw("Strict value is not equal to itself.")
659+                        }
660+
661+                    let actions = {
662+                        let $l = priceAssets
663+                        let $s = size($l)
664+                        let $acc0 = unit
665+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
666+                            then $a
667+                            else cb($a, $l[$i])
668+
669+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
670+                            then $a
671+                            else throw("List size exceeds 1")
672+
673+                        $f0_2($f0_1($acc0, 0), 1)
674+                        }
675+                    if ((actions == actions))
676+                        then $Tuple2(nil, unit)
677+                        else throw("Strict value is not equal to itself.")
678+                    }
679+                else throw("Strict value is not equal to itself.")
680+            }
681+        else throw("Strict value is not equal to itself.")
682+    }
683+
684+
629685 @Verifier(tx)
630686 func verify () = {
631687     let targetPublicKey =     match managerPublicKeyOrUnit() {

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
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 decimalsMultPrice = ((100 * 1000) * 1000)
1919 
2020 let SEP = "__"
2121 
2222 let EMPTY = ""
2323 
2424 let PoolActive = 1
2525 
2626 let PoolPutDisabled = 2
2727 
2828 let PoolMatcherDisabled = 3
2929 
3030 let PoolShutdown = 4
3131 
3232 let idxInternalAssetId = 1
3333 
3434 let idxResutActions = 2
3535 
3636 let idxIfAssetIdCalculationPerformed = 3
3737 
3838 let idxPoolAddress = 1
3939 
4040 let idxPoolStatus = 2
4141 
4242 let idxPoolLPAssetId = 3
4343 
4444 let idxAmtAssetId = 4
4545 
4646 let idxPriceAssetId = 5
4747 
4848 let idxAmtAssetDcm = 6
4949 
5050 let idxPriceAssetDcm = 7
5151 
5252 let idxIAmtAssetId = 8
5353 
5454 let idxIPriceAssetId = 9
5555 
5656 let idxLPAssetDcm = 10
5757 
5858 let idxPoolType = 11
5959 
6060 let poolLabelWxEmission = "WX_EMISSION"
6161 
6262 let validPoolLabels = [poolLabelWxEmission]
6363 
6464 func keyFactoryConfig () = "%s__factoryConfig"
6565 
6666 
6767 func keyLpTokensList () = "%s__lpTokensList"
6868 
6969 
7070 func keyPoolScriptHash () = "%s%s__pool__scriptHash"
7171 
7272 
7373 func keyMatcherPub () = "%s%s__matcher__publicKey"
7474 
7575 
7676 func keyLegacyFactoryContract () = "%s__legacyFactoryContract"
7777 
7878 
7979 func keyLegacyPools () = "%s__legacyPools"
8080 
8181 
8282 func keyManagerPublicKey () = "%s__managerPublicKey"
8383 
8484 
8585 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
8686 
8787 
8888 func keyAdminPubKeys () = "%s__adminPubKeys"
8989 
9090 
9191 func keyAssetsStoreContract () = "%s__assetsStoreContract"
9292 
9393 
9494 func keyVotingEmissionContract () = "%s__votingEmissionContract"
9595 
9696 
97+func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
98+
99+
97100 func keyPriceDecimals () = "%s__priceDecimals"
98101 
99102 
100103 func keyAllPoolsShutdown () = "%s__shutdown"
101104 
102105 
103106 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
104107 
105108 
106109 func keyPoolToWeight (poolAddress) = ("%s%s__poolWeight__" + poolAddress)
107110 
108111 
109112 func keyPoolToWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
110113 
111114 
112115 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
113116 
114117 
115118 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
116119 
117120 
118121 func keyPoolConfig (amountAssetInternal,priceAssetInternal) = (((("%d%d%s__" + amountAssetInternal) + "__") + priceAssetInternal) + "__config")
119122 
120123 
121124 func keyMappingLpAssetToPoolAssets (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2Pool")
122125 
123126 
124127 func keyMappingPoolAssetsToLpasset (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + internalAmountAssetIdStr) + "__") + internalPriceAssetIdStr) + "__mappings__PoolAssets2LpAsset")
125128 
126129 
127130 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
128131 
129132 
130133 func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
131134 
132135 
133136 func keyMappingPoolContractToLPAsset (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
134137 
135138 
136139 func keyMappingPoolLPAssetToPoolContractAddress (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2PoolContract")
137140 
138141 
139142 func keyWxEmission (amountAssetId,priceAssetId) = ((("%s%s%s__wxEmission__" + amountAssetId) + "__") + priceAssetId)
140143 
141144 
142145 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
143146 
144147 
145148 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
146149 
147150 
148151 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
149152 
150153 
151154 let IdxFactoryCfgStakingDapp = 1
152155 
153156 let IdxFactoryCfgBoostingDapp = 2
154157 
155158 let IdxFactoryCfgIdoDapp = 3
156159 
157160 let IdxFactoryCfgTeamDapp = 4
158161 
159162 let IdxFactoryCfgEmissionDapp = 5
160163 
161164 let IdxFactoryCfgRestDapp = 6
162165 
163166 let IdxFactoryCfgSlippageDapp = 7
164167 
165168 let IdxFactoryCfgDaoDapp = 8
166169 
167170 let IdxFactoryCfgMarketingDapp = 9
168171 
169172 let IdxFactoryCfgGwxRewardDapp = 10
170173 
171174 let IdxFactoryCfgBirdsDapp = 11
172175 
173176 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
174177 
175178 
176179 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
177180 
178181 
179182 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
180183 
181184 
182185 func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
186+
187+
188+func getPriceAssets () = match getString(keyPriceAssets()) {
189+    case s: String => 
190+        if ((size(s) == 0))
191+            then nil
192+            else split(s, SEP)
193+    case _ => 
194+        nil
195+}
183196 
184197 
185198 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
186199     case s: String => 
187200         fromBase58String(s)
188201     case _: Unit => 
189202         unit
190203     case _ => 
191204         throw("Match error")
192205 }
193206 
194207 
195208 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
196209     case s: String => 
197210         fromBase58String(s)
198211     case _: Unit => 
199212         unit
200213     case _ => 
201214         throw("Match error")
202215 }
203216 
204217 
205218 func mustManager (i) = {
206219     let pd = throw("Permission denied")
207220     match managerPublicKeyOrUnit() {
208221         case pk: ByteVector => 
209222             if ((i.callerPublicKey == pk))
210223                 then true
211224                 else pd
212225         case _: Unit => 
213226             if ((i.caller == this))
214227                 then true
215228                 else pd
216229         case _ => 
217230             throw("Match error")
218231     }
219232     }
220233 
221234 
222235 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)
223236 
224237 
225238 func dataFactoryCfg (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract) = makeString(["%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract], SEP)
226239 
227240 
228241 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)
229242 
230243 
231244 func dataMappingPoolAssets (internalAmountAssetStr,internalPriceAssetStr) = makeString(["%d%d", toString(internalAmountAssetStr), toString(internalPriceAssetStr)], SEP)
232245 
233246 
234247 func getPoolConfig (poolAddress) = {
235248     let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
236249     let amountAssetInternal = poolAssets[1]
237250     let priceAssetInternal = poolAssets[2]
238251     split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
239252     }
240253 
241254 
242255 func getInternalAssetIdOrCreate (assetIdStr,incrementor) = {
243256     let internalAssetId = valueOrElse(getInteger(this, keyMappingsBaseAsset2internalId(assetIdStr)), 0)
244257     let currentIndexOfInternalId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
245258     let result = if ((internalAssetId == 0))
246259         then {
247260             let newInternalAssetId = (currentIndexOfInternalId + incrementor)
248261             $Tuple3(newInternalAssetId, [IntegerEntry(keyNextInternalAssetId(), newInternalAssetId), IntegerEntry(keyMappingsBaseAsset2internalId(assetIdStr), newInternalAssetId), StringEntry(keyMappingsInternal2baseAssetId(newInternalAssetId), assetIdStr)], true)
249262             }
250263         else $Tuple3(internalAssetId, nil, false)
251264     result
252265     }
253266 
254267 
255268 func createLpTokensListEntry (newLpToken) = {
256269     let lpTokens = getString(this, keyLpTokensList())
257270     if (isDefined(lpTokens))
258271         then ((value(lpTokens) + SEP) + newLpToken)
259272         else newLpToken
260273     }
261274 
262275 
263276 func mustAdmin (i) = {
264277     let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
265278     if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
266279         then true
267280         else {
268281             let isManager = mustManager(i)
269282             if ((isManager == isManager))
270283                 then true
271284                 else throw("Strict value is not equal to itself.")
272285             }
273286     }
274287 
275288 
276289 @Callable(i)
277290 func constructor (stakingContract,boostingContract,idoContract,teamContract,emissionContract,restContract,slpipageContract,priceDecimals) = {
278291     let checkCaller = mustManager(i)
279292     if ((checkCaller == checkCaller))
280293         then [StringEntry(keyFactoryConfig(), dataFactoryCfg(stakingContract, boostingContract, idoContract, teamContract, emissionContract, restContract, slpipageContract)), IntegerEntry(keyPriceDecimals(), priceDecimals)]
281294         else throw("Strict value is not equal to itself.")
282295     }
283296 
284297 
285298 
286299 @Callable(i)
287300 func constructorV2 (mathcherPub58Str) = {
288301     let checkCaller = mustManager(i)
289302     if ((checkCaller == checkCaller))
290303         then {
291304             let mathcerPub = addressFromPublicKey(fromBase58String(mathcherPub58Str))
292305             if ((mathcerPub == mathcerPub))
293306                 then [StringEntry(keyMatcherPub(), mathcherPub58Str)]
294307                 else throw("Strict value is not equal to itself.")
295308             }
296309         else throw("Strict value is not equal to itself.")
297310     }
298311 
299312 
300313 
301314 @Callable(i)
302315 func constructorV3 (daoContract,marketingContract,gwxRewardsContract,birdsContract) = {
303316     let checkCaller = mustManager(i)
304317     if ((checkCaller == checkCaller))
305318         then {
306319             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
307320 [StringEntry(keyFactoryConfig(), dataFactoryCfgV3(factoryCfg[1], factoryCfg[2], factoryCfg[3], factoryCfg[4], factoryCfg[5], factoryCfg[6], factoryCfg[7], daoContract, marketingContract, gwxRewardsContract, birdsContract))]
308321             }
309322         else throw("Strict value is not equal to itself.")
310323     }
311324 
312325 
313326 
314327 @Callable(i)
315328 func constructorV4 (legacyFactoryContract,legacyPools) = {
316329     let checkCaller = mustManager(i)
317330     if ((checkCaller == checkCaller))
318331         then [StringEntry(keyLegacyFactoryContract(), legacyFactoryContract), StringEntry(keyLegacyPools(), makeString(legacyPools, SEP))]
319332         else throw("Strict value is not equal to itself.")
320333     }
321334 
322335 
323336 
324337 @Callable(i)
325338 func constructorV5 (assetsStoreContract) = {
326339     let checkCaller = mustManager(i)
327340     if ((checkCaller == checkCaller))
328341         then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
329342         else throw("Strict value is not equal to itself.")
330343     }
331344 
332345 
333346 
334347 @Callable(i)
335-func constructorV6 (votingEmissionContract) = {
348+func constructorV6 (votingEmissionContract,priceAssets) = {
336349     let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
337350         then true
338351         else "invalid voting emission contract address"]
339352     if ((cheks == cheks))
340-        then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
353+        then [StringEntry(keyVotingEmissionContract(), votingEmissionContract), StringEntry(keyPriceAssets(), makeString(priceAssets, SEP))]
341354         else throw("Strict value is not equal to itself.")
342355     }
343356 
344357 
345358 
346359 @Callable(i)
347360 func setManager (pendingManagerPublicKey) = {
348361     let checkCaller = mustManager(i)
349362     if ((checkCaller == checkCaller))
350363         then {
351364             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
352365             if ((checkManagerPublicKey == checkManagerPublicKey))
353366                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
354367                 else throw("Strict value is not equal to itself.")
355368             }
356369         else throw("Strict value is not equal to itself.")
357370     }
358371 
359372 
360373 
361374 @Callable(i)
362375 func confirmManager () = {
363376     let pm = pendingManagerPublicKeyOrUnit()
364377     let hasPM = if (isDefined(pm))
365378         then true
366379         else throw("No pending manager")
367380     if ((hasPM == hasPM))
368381         then {
369382             let checkPM = if ((i.callerPublicKey == value(pm)))
370383                 then true
371384                 else throw("You are not pending manager")
372385             if ((checkPM == checkPM))
373386                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
374387                 else throw("Strict value is not equal to itself.")
375388             }
376389         else throw("Strict value is not equal to itself.")
377390     }
378391 
379392 
380393 
381394 @Callable(i)
382395 func setAdmins (adminPubKeys) = {
383396     let checkCaller = mustManager(i)
384397     if ((checkCaller == checkCaller))
385398         then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
386399         else throw("Strict value is not equal to itself.")
387400     }
388401 
389402 
390403 
391404 @Callable(i)
392405 func activateNewPool (poolAddress,amountAssetStr,priceAssetStr,lpAssetName,lpAssetDescr,poolWeight,poolType,logo) = {
393406     let checkCaller = mustAdmin(i)
394407     if ((checkCaller == checkCaller))
395408         then if (isDefined(getString(keyMappingPoolContractAddressToPoolAssets(poolAddress))))
396409             then throw((("Pool address " + poolAddress) + " already registered."))
397410             else {
398411                 let internalAmountAssetData = getInternalAssetIdOrCreate(amountAssetStr, 1)
399412                 let internalAmountAssetId = internalAmountAssetData._1
400413                 let internalPriceAssetData = getInternalAssetIdOrCreate(priceAssetStr, if (internalAmountAssetData._3)
401414                     then 2
402415                     else 1)
403416                 let internalPriceAssetId = internalPriceAssetData._1
404417                 let poolAccountScriptHash = valueOrErrorMessage(scriptHash(addressFromStringValue(poolAddress)), ("No script has been found on pool account " + poolAddress))
405418                 let ethalonPoolAccountScriptHash = getBinaryValue(keyPoolScriptHash())
406419                 let poolConfig = getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)))
407420                 if (isDefined(poolConfig))
408421                     then throw((((("Pool " + amountAssetStr) + "/") + priceAssetStr) + " has already been activated."))
409422                     else {
410423                         let poolConfigValue = value(getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId))))
411424                         let amountAssetsDecimals = if ((amountAssetStr == "WAVES"))
412425                             then decimalsMultPrice
413426                             else pow(10, 0, value(assetInfo(fromBase58String(amountAssetStr))).decimals, 0, 0, DOWN)
414427                         let priceAssetsDecimals = if ((priceAssetStr == "WAVES"))
415428                             then decimalsMultPrice
416429                             else pow(10, 0, value(assetInfo(fromBase58String(priceAssetStr))).decimals, 0, 0, DOWN)
417430                         let lpAssetIssueAction = Issue(lpAssetName, lpAssetDescr, 1, 8, true)
418431                         let lpAssetId = calculateAssetId(lpAssetIssueAction)
419432                         let lpAssetIdStr = toBase58String(lpAssetId)
420433                         let poolActivateInvokeResult = invoke(addressFromStringValue(poolAddress), "activate", [amountAssetStr, priceAssetStr], nil)
421434                         if ((poolActivateInvokeResult == poolActivateInvokeResult))
422435                             then if ((poolActivateInvokeResult != "success"))
423436                                 then throw("Pool initialisation error happened.")
424437                                 else {
425438                                     let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract()))
426439                                     let createOrUpdateLpAssetInv = invoke(assetsStoreContract, "createOrUpdate", [lpAssetIdStr, lpAssetName, false], nil)
427440                                     if ((createOrUpdateLpAssetInv == createOrUpdateLpAssetInv))
428441                                         then {
429442                                             let addPoolsLpLabelInv = invoke(assetsStoreContract, "addLabel", [lpAssetIdStr, labelPoolsLp], nil)
430443                                             if ((addPoolsLpLabelInv == addPoolsLpLabelInv))
431444                                                 then {
432445                                                     let setLogoInv = invoke(assetsStoreContract, "setLogo", [lpAssetIdStr, logo], nil)
433446                                                     if ((setLogoInv == setLogoInv))
434447                                                         then {
435448                                                             let addAssetsLinkInv = invoke(assetsStoreContract, "addAssetsLink", [amountAssetStr, priceAssetStr, lpAssetIdStr], nil)
436449                                                             if ((addAssetsLinkInv == addAssetsLinkInv))
437450                                                                 then {
438451                                                                     let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
439452                                                                     if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
440453                                                                         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), StringEntry(keyLpTokensList(), createLpTokensListEntry(lpAssetIdStr))]), lpAssetIdStr)
441454                                                                         else throw("Strict value is not equal to itself.")
442455                                                                     }
443456                                                                 else throw("Strict value is not equal to itself.")
444457                                                             }
445458                                                         else throw("Strict value is not equal to itself.")
446459                                                     }
447460                                                 else throw("Strict value is not equal to itself.")
448461                                             }
449462                                         else throw("Strict value is not equal to itself.")
450463                                     }
451464                             else throw("Strict value is not equal to itself.")
452465                         }
453466                 }
454467         else throw("Strict value is not equal to itself.")
455468     }
456469 
457470 
458471 
459472 @Callable(i)
460473 func managePool (poolAddress,newStatus) = {
461474     let checkCaller = mustManager(i)
462475     if ((checkCaller == checkCaller))
463476         then {
464477             let poolConfig = getPoolConfig(poolAddress)
465478             let poolStatus = poolConfig[idxPoolStatus]
466479             let lpAssetIdStr = poolConfig[idxPoolLPAssetId]
467480             let amountAssetStr = poolConfig[idxAmtAssetId]
468481             let priceAssetStr = poolConfig[idxPriceAssetId]
469482             let amountAssetsDecimals = parseIntValue(poolConfig[idxAmtAssetDcm])
470483             let priceAssetsDecimals = parseIntValue(poolConfig[idxPriceAssetDcm])
471484             let internalAmountAssetId = parseIntValue(poolConfig[idxIAmtAssetId])
472485             let internalPriceAssetId = parseIntValue(poolConfig[idxIPriceAssetId])
473486             let lpAssetDcm = parseIntValue(poolConfig[idxLPAssetDcm])
474487             let poolType = poolConfig[idxPoolType]
475488 [StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(newStatus), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, lpAssetDcm, poolType))]
476489             }
477490         else throw("Strict value is not equal to itself.")
478491     }
479492 
480493 
481494 
482495 @Callable(i)
483496 func emit (amountToEmit) = {
484497     let caller = i.caller
485498     let originCaller = i.originCaller
486499     let lpAssetRequested = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
487500     let lpAsset = fromBase58String(lpAssetRequested)
488501     let legacyPools = split(valueOrElse(getString(keyLegacyPools()), EMPTY), SEP)
489502     let legacyFactoryContract = addressFromStringValue(valueOrErrorMessage(getString(keyLegacyFactoryContract()), "Legacy factory contract does not exists."))
490503     if ((0 >= amountToEmit))
491504         then nil
492505         else if (containsElement(legacyPools, toString(caller)))
493506             then $Tuple2(nil, legacyFactoryContract)
494507             else $Tuple2([Reissue(lpAsset, amountToEmit, true), ScriptTransfer(i.caller, amountToEmit, lpAsset)], "success")
495508     }
496509 
497510 
498511 
499512 @Callable(i)
500513 func burn (amountToBurn) = {
501514     let caller = i.caller
502515     let originCaller = i.originCaller
503516     let payment = value(i.payments[0])
504517     let paymentAmount = value(payment.amount)
505518     let inAmountAssetId = toBase58String(value(payment.assetId))
506519     let lpAssetRequestedForBurning = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
507520     if ((inAmountAssetId != lpAssetRequestedForBurning))
508521         then throw("Invalid asset passed.")
509522         else if ((amountToBurn != paymentAmount))
510523             then throw("Invalid amount passed.")
511524             else {
512525                 let lpAsset = fromBase58String(lpAssetRequestedForBurning)
513526                 $Tuple2([Burn(lpAsset, amountToBurn)], "success")
514527                 }
515528     }
516529 
517530 
518531 
519532 @Callable(i)
520533 func modifyWeight (lpAssetId,share) = {
521534     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
522535         then true
523536         else mustManager(i)
524537     if ((checkCaller == checkCaller))
525538         then {
526539             let poolContractAddress = getStringOrFail(keyMappingPoolLPAssetToPoolContractAddress(lpAssetId))
527540             let poolWeightKey = keyPoolToWeight(poolContractAddress)
528541             let gwxWeight = valueOrElse(getInteger(keyPoolToWeight(GWXvirtualPOOL)), 0)
529542             let poolWeight = valueOrElse(getInteger(poolWeightKey), 0)
530543             let poolWeightNew = fraction(share, (POOLWEIGHTMULT - gwxWeight), POOLWEIGHTMULT)
531544             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
532545             let stakingContract = getStakingAddressOrFail(factoryCfg)
533546             let onModifyWeightInv = invoke(stakingContract, "onModifyWeight", [lpAssetId, poolContractAddress], nil)
534547             if ((onModifyWeightInv == onModifyWeightInv))
535548                 then [IntegerEntry(poolWeightKey, poolWeightNew)]
536549                 else throw("Strict value is not equal to itself.")
537550             }
538551         else throw("Strict value is not equal to itself.")
539552     }
540553 
541554 
542555 
543556 @Callable(i)
544557 func modifyWeights (btcPoolAddress,ethPoolAddress,ethBtcPoolAddress,usdcUsdtPoolAddress) = {
545558     let checkCaller = mustManager(i)
546559     if ((checkCaller == checkCaller))
547560         then {
548561             let ethBtcWeightNew = ((5 * POOLWEIGHTMULT) / 100)
549562             let usdcUsdtWeightNew = ((5 * POOLWEIGHTMULT) / 100)
550563             let weightDecrement = ((5 * POOLWEIGHTMULT) / 100)
551564             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
552565             let stakingDapp = getStakingAddressOrFail(factoryCfg)
553566             let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
554567             let btcWeightKEY = keyPoolToWeight(btcPoolAddress)
555568             let ethWeightKEY = keyPoolToWeight(ethPoolAddress)
556569             let ethBtcWeightKEY = keyPoolToWeight(ethBtcPoolAddress)
557570             let usdcUsdtWeightKEY = keyPoolToWeight(usdcUsdtPoolAddress)
558571             let btcWeight = getIntOrFail(btcWeightKEY)
559572             let ethWeight = getIntOrFail(ethWeightKEY)
560573             let btcWeightNew = (btcWeight - weightDecrement)
561574             let ethWeightNew = (ethWeight - weightDecrement)
562575             if ((0 >= btcWeightNew))
563576                 then throw(("invalid btcWeightNew: " + toString(btcWeightNew)))
564577                 else if ((0 >= ethWeightNew))
565578                     then throw(("invalid ethWeightNew: " + toString(ethWeightNew)))
566579                     else {
567580                         let btcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(btcPoolAddress))
568581                         let ethLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethPoolAddress))
569582                         let ethBtcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethBtcPoolAddress))
570583                         let usdcUsdtLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(usdcUsdtPoolAddress))
571584                         let onModifyWeightBtc = invoke(stakingDapp, "onModifyWeight", [btcLpAssetIdStr, btcPoolAddress], nil)
572585                         if ((onModifyWeightBtc == onModifyWeightBtc))
573586                             then {
574587                                 let onModifyWeightEth = invoke(stakingDapp, "onModifyWeight", [ethLpAssetIdStr, ethPoolAddress], nil)
575588                                 if ((onModifyWeightEth == onModifyWeightEth))
576589                                     then {
577590                                         let onModifyWeightEthBtc = invoke(stakingDapp, "onModifyWeight", [ethBtcLpAssetIdStr, ethBtcPoolAddress], nil)
578591                                         if ((onModifyWeightEthBtc == onModifyWeightEthBtc))
579592                                             then {
580593                                                 let onModifyWeightUsdcUsdt = invoke(stakingDapp, "onModifyWeight", [usdcUsdtLpAssetIdStr, usdcUsdtPoolAddress], nil)
581594                                                 if ((onModifyWeightUsdcUsdt == onModifyWeightUsdcUsdt))
582595                                                     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)]
583596                                                     else throw("Strict value is not equal to itself.")
584597                                                 }
585598                                             else throw("Strict value is not equal to itself.")
586599                                         }
587600                                     else throw("Strict value is not equal to itself.")
588601                                 }
589602                             else throw("Strict value is not equal to itself.")
590603                         }
591604             }
592605         else throw("Strict value is not equal to itself.")
593606     }
594607 
595608 
596609 
597610 @Callable(i)
598611 func checkWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
599612     let haveLabel =     match getBoolean(keyWxEmission(amountAssetId, priceAssetId)) {
600613         case b: Boolean => 
601614             b
602615         case _ => 
603616             false
604617     }
605618     $Tuple2(nil, haveLabel)
606619     }
607620 
608621 
609622 
610623 @Callable(i)
611624 func setWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
612625     let checkCaller = mustAdmin(i)
613626     if ((checkCaller == checkCaller))
614627         then $Tuple2([BooleanEntry(keyWxEmission(amountAssetId, priceAssetId), true)], unit)
615628         else throw("Strict value is not equal to itself.")
616629     }
617630 
618631 
619632 
620633 @Callable(i)
621634 func deleteWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
622635     let checkCaller = mustAdmin(i)
623636     if ((checkCaller == checkCaller))
624637         then $Tuple2([DeleteEntry(keyWxEmission(amountAssetId, priceAssetId))], unit)
625638         else throw("Strict value is not equal to itself.")
626639     }
627640 
628641 
642+
643+@Callable(i)
644+func onVerificationLoss (assetId) = {
645+    let checkCaller = mustAdmin(i)
646+    if ((checkCaller == checkCaller))
647+        then {
648+            let priceAssets = getPriceAssets()
649+            let checkPriceAssetsSize = if ((size(priceAssets) > 0))
650+                then true
651+                else throw("invalid price assets")
652+            if ((checkPriceAssetsSize == checkPriceAssetsSize))
653+                then {
654+                    func cb (acc,priceAsset) =                     {
655+                        let r = invoke(this, "deleteWxEmissionPoolLabel", [assetId, priceAsset], nil)
656+                        if ((r == r))
657+                            then unit
658+                            else throw("Strict value is not equal to itself.")
659+                        }
660+
661+                    let actions = {
662+                        let $l = priceAssets
663+                        let $s = size($l)
664+                        let $acc0 = unit
665+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
666+                            then $a
667+                            else cb($a, $l[$i])
668+
669+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
670+                            then $a
671+                            else throw("List size exceeds 1")
672+
673+                        $f0_2($f0_1($acc0, 0), 1)
674+                        }
675+                    if ((actions == actions))
676+                        then $Tuple2(nil, unit)
677+                        else throw("Strict value is not equal to itself.")
678+                    }
679+                else throw("Strict value is not equal to itself.")
680+            }
681+        else throw("Strict value is not equal to itself.")
682+    }
683+
684+
629685 @Verifier(tx)
630686 func verify () = {
631687     let targetPublicKey =     match managerPublicKeyOrUnit() {
632688         case pk: ByteVector => 
633689             pk
634690         case _: Unit => 
635691             tx.senderPublicKey
636692         case _ => 
637693             throw("Match error")
638694     }
639695     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
640696     }
641697 
github/deemru/w8io/169f3d6 
76.35 ms ◑