tx · 5s1c2wvyofK97nrcYbSCuivwg89STjBQedNXenb2uTzS

3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai:  -0.01400000 Waves

2022.04.15 12:53 [2009521] smart account 3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5s1c2wvyofK97nrcYbSCuivwg89STjBQedNXenb2uTzS",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1650016385686,
    "version": 1,
    "sender": "3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai",
    "senderPublicKey": "2JEaBjtjvMoNGKZmL9QxYefa1VkMJM3vMW8rNvTs9R2H",
    "proofs": [
        "5Pd2H3aTErtQSUimK1TBEJi9kSu9eM4JdvydaEpWsQfyh1pqpFP1nsFpSTymorpFYBQoBcHjzS4AZFu5mUox9V58"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2009521,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: F1SK7dg4DNo4JgPHTmVLgx5ovnZShKmYFnFWpk7YTBUY
Next: 3Tx4TMZ78hzEuNxGhCrK4QUp22JjKubQKvtEuWEpsvES

Diff: 

OldNewDifferences
1212 let POOLWEIGHTMULT = MULT8
1313 
1414 let GWXvirtualPOOL = "GWXvirtualPOOL"
15+
16+let labelPoolsLp = "POOLS_LP"
1517 
1618 let decimalsMultPrice = ((100 * 1000) * 1000)
1719 
7779 
7880 
7981 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
82+
83+
84+func keyAdminPubKeys () = "%s__adminPubKeys"
85+
86+
87+func keyAssetsStoreContract () = "%s__assetsStoreContract"
8088 
8189 
8290 func keyPriceDecimals () = "%s__priceDecimals"
242250     }
243251 
244252 
253+func mustAdmin (i) = {
254+    let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
255+    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
256+        then true
257+        else {
258+            let isManager = mustManager(i)
259+            if ((isManager == isManager))
260+                then true
261+                else throw("Strict value is not equal to itself.")
262+            }
263+    }
264+
265+
245266 @Callable(i)
246267 func constructor (stakingContract,boostingContract,idoContract,teamContract,emissionContract,restContract,slpipageContract,priceDecimals) = {
247268     let checkCaller = mustManager(i)
291312 
292313 
293314 @Callable(i)
315+func constructorV5 (assetsStoreContract) = {
316+    let checkCaller = mustManager(i)
317+    if ((checkCaller == checkCaller))
318+        then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
319+        else throw("Strict value is not equal to itself.")
320+    }
321+
322+
323+
324+@Callable(i)
294325 func setManager (pendingManagerPublicKey) = {
295326     let checkCaller = mustManager(i)
296327     if ((checkCaller == checkCaller))
326357 
327358 
328359 @Callable(i)
360+func setAdmins (adminPubKeys) = {
361+    let checkCaller = mustManager(i)
362+    if ((checkCaller == checkCaller))
363+        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
364+        else throw("Strict value is not equal to itself.")
365+    }
366+
367+
368+
369+@Callable(i)
329370 func activateNewPool (poolAddress,amountAssetStr,priceAssetStr,lpAssetName,lpAssetDescr,poolWeight,poolType) = {
330-    let checkCaller = mustManager(i)
371+    let checkCaller = mustAdmin(i)
331372     if ((checkCaller == checkCaller))
332373         then if (isDefined(getString(keyMappingPoolContractAddressToPoolAssets(poolAddress))))
333374             then throw((("Pool address " + poolAddress) + " already registered."))
358399                         if ((poolActivateInvokeResult == poolActivateInvokeResult))
359400                             then if ((poolActivateInvokeResult != "success"))
360401                                 then throw("Pool initialisation error happened.")
361-                                else $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(keyMappingPoolContracToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight), StringEntry(keyLpTokensList(), createLpTokensListEntry(lpAssetIdStr))]), "success")
402+                                else {
403+                                    let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract()))
404+                                    let isAmountAssetVerified =                                     match invoke(assetsStoreContract, "isVerifiedREADONLY", [amountAssetStr], nil) {
405+                                        case b: Boolean => 
406+                                            b
407+                                        case _ => 
408+                                            false
409+                                    }
410+                                    let createOrUpdateLpAssetInv = invoke(assetsStoreContract, "createOrUpdate", [lpAssetIdStr, lpAssetName, "", isAmountAssetVerified], nil)
411+                                    if ((createOrUpdateLpAssetInv == createOrUpdateLpAssetInv))
412+                                        then {
413+                                            let addPoolsLpLabelInv = invoke(assetsStoreContract, "addLabel", [lpAssetIdStr, labelPoolsLp], nil)
414+                                            if ((addPoolsLpLabelInv == addPoolsLpLabelInv))
415+                                                then {
416+                                                    let addAssetsLinkInv = invoke(assetsStoreContract, "addAssetsLink", [amountAssetStr, priceAssetStr, lpAssetIdStr], nil)
417+                                                    if ((addAssetsLinkInv == addAssetsLinkInv))
418+                                                        then {
419+                                                            let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
420+                                                            if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
421+                                                                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(keyMappingPoolContracToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight), StringEntry(keyLpTokensList(), createLpTokensListEntry(lpAssetIdStr))]), lpAssetIdStr)
422+                                                                else throw("Strict value is not equal to itself.")
423+                                                            }
424+                                                        else throw("Strict value is not equal to itself.")
425+                                                    }
426+                                                else throw("Strict value is not equal to itself.")
427+                                            }
428+                                        else throw("Strict value is not equal to itself.")
429+                                    }
362430                             else throw("Strict value is not equal to itself.")
363431                         }
364432                 }

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"
15+
16+let labelPoolsLp = "POOLS_LP"
1517 
1618 let decimalsMultPrice = ((100 * 1000) * 1000)
1719 
1820 let SEP = "__"
1921 
2022 let EMPTY = ""
2123 
2224 let PoolActive = 1
2325 
2426 let PoolPutDisabled = 2
2527 
2628 let PoolMatcherDisabled = 3
2729 
2830 let PoolShutdown = 4
2931 
3032 let idxInternalAssetId = 1
3133 
3234 let idxResutActions = 2
3335 
3436 let idxIfAssetIdCalculationPerformed = 3
3537 
3638 let idxPoolAddress = 1
3739 
3840 let idxPoolStatus = 2
3941 
4042 let idxPoolLPAssetId = 3
4143 
4244 let idxAmtAssetId = 4
4345 
4446 let idxPriceAssetId = 5
4547 
4648 let idxAmtAssetDcm = 6
4749 
4850 let idxPriceAssetDcm = 7
4951 
5052 let idxIAmtAssetId = 8
5153 
5254 let idxIPriceAssetId = 9
5355 
5456 let idxLPAssetDcm = 10
5557 
5658 let idxPoolType = 11
5759 
5860 func keyFactoryConfig () = "%s__factoryConfig"
5961 
6062 
6163 func keyLpTokensList () = "%s__lpTokensList"
6264 
6365 
6466 func keyPoolScriptHash () = "%s%s__pool__scriptHash"
6567 
6668 
6769 func keyMatcherPub () = "%s%s__matcher__publicKey"
6870 
6971 
7072 func keyLegacyFactoryContract () = "%s__legacyFactoryContract"
7173 
7274 
7375 func keyLegacyPools () = "%s__legacyPools"
7476 
7577 
7678 func keyManagerPublicKey () = "%s__managerPublicKey"
7779 
7880 
7981 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
82+
83+
84+func keyAdminPubKeys () = "%s__adminPubKeys"
85+
86+
87+func keyAssetsStoreContract () = "%s__assetsStoreContract"
8088 
8189 
8290 func keyPriceDecimals () = "%s__priceDecimals"
8391 
8492 
8593 func keyAllPoolsShutdown () = "%s__shutdown"
8694 
8795 
8896 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
8997 
9098 
9199 func keyPoolToWeight (poolAddress) = ("%s%s__poolWeight__" + poolAddress)
92100 
93101 
94102 func keyPoolToWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
95103 
96104 
97105 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
98106 
99107 
100108 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
101109 
102110 
103111 func keyPoolConfig (amountAssetInternal,priceAssetInternal) = (((("%d%d%s__" + amountAssetInternal) + "__") + priceAssetInternal) + "__config")
104112 
105113 
106114 func keyMappingLpAssetToPoolAssets (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2Pool")
107115 
108116 
109117 func keyMappingPoolAssetsToLpasset (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + internalAmountAssetIdStr) + "__") + internalPriceAssetIdStr) + "__mappings__PoolAssets2LpAsset")
110118 
111119 
112120 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
113121 
114122 
115123 func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
116124 
117125 
118126 func keyMappingPoolContracToLPAsset (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
119127 
120128 
121129 func keyMappingPoolLPAssetToPoolContractAddress (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2PoolContract")
122130 
123131 
124132 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
125133 
126134 
127135 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
128136 
129137 
130138 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
131139 
132140 
133141 let IdxFactoryCfgStakingDapp = 1
134142 
135143 let IdxFactoryCfgBoostingDapp = 2
136144 
137145 let IdxFactoryCfgIdoDapp = 3
138146 
139147 let IdxFactoryCfgTeamDapp = 4
140148 
141149 let IdxFactoryCfgEmissionDapp = 5
142150 
143151 let IdxFactoryCfgRestDapp = 6
144152 
145153 let IdxFactoryCfgSlippageDapp = 7
146154 
147155 let IdxFactoryCfgDaoDapp = 8
148156 
149157 let IdxFactoryCfgMarketingDapp = 9
150158 
151159 let IdxFactoryCfgGwxRewardDapp = 10
152160 
153161 let IdxFactoryCfgBirdsDapp = 11
154162 
155163 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
156164 
157165 
158166 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
159167 
160168 
161169 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
162170 
163171 
164172 func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
165173 
166174 
167175 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
168176     case s: String => 
169177         fromBase58String(s)
170178     case _: Unit => 
171179         unit
172180     case _ => 
173181         throw("Match error")
174182 }
175183 
176184 
177185 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
178186     case s: String => 
179187         fromBase58String(s)
180188     case _: Unit => 
181189         unit
182190     case _ => 
183191         throw("Match error")
184192 }
185193 
186194 
187195 func mustManager (i) = {
188196     let pd = throw("Permission denied")
189197     match managerPublicKeyOrUnit() {
190198         case pk: ByteVector => 
191199             if ((i.callerPublicKey == pk))
192200                 then true
193201                 else pd
194202         case _: Unit => 
195203             if ((i.caller == this))
196204                 then true
197205                 else pd
198206         case _ => 
199207             throw("Match error")
200208     }
201209     }
202210 
203211 
204212 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)
205213 
206214 
207215 func dataFactoryCfg (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract) = makeString(["%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract], SEP)
208216 
209217 
210218 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)
211219 
212220 
213221 func dataMappingPoolAssets (internalAmountAssetStr,internalPriceAssetStr) = makeString(["%d%d", toString(internalAmountAssetStr), toString(internalPriceAssetStr)], SEP)
214222 
215223 
216224 func getPoolConfig (poolAddress) = {
217225     let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
218226     let amountAssetInternal = poolAssets[1]
219227     let priceAssetInternal = poolAssets[2]
220228     split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
221229     }
222230 
223231 
224232 func getInternalAssetIdOrCreate (assetIdStr,incrementor) = {
225233     let internalAssetId = valueOrElse(getInteger(this, keyMappingsBaseAsset2internalId(assetIdStr)), 0)
226234     let currentIndexOfInternalId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
227235     let result = if ((internalAssetId == 0))
228236         then {
229237             let newInternalAssetId = (currentIndexOfInternalId + incrementor)
230238             $Tuple3(newInternalAssetId, [IntegerEntry(keyNextInternalAssetId(), newInternalAssetId), IntegerEntry(keyMappingsBaseAsset2internalId(assetIdStr), newInternalAssetId), StringEntry(keyMappingsInternal2baseAssetId(newInternalAssetId), assetIdStr)], true)
231239             }
232240         else $Tuple3(internalAssetId, nil, false)
233241     result
234242     }
235243 
236244 
237245 func createLpTokensListEntry (newLpToken) = {
238246     let lpTokens = getString(this, keyLpTokensList())
239247     if (isDefined(lpTokens))
240248         then ((value(lpTokens) + SEP) + newLpToken)
241249         else newLpToken
242250     }
243251 
244252 
253+func mustAdmin (i) = {
254+    let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
255+    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
256+        then true
257+        else {
258+            let isManager = mustManager(i)
259+            if ((isManager == isManager))
260+                then true
261+                else throw("Strict value is not equal to itself.")
262+            }
263+    }
264+
265+
245266 @Callable(i)
246267 func constructor (stakingContract,boostingContract,idoContract,teamContract,emissionContract,restContract,slpipageContract,priceDecimals) = {
247268     let checkCaller = mustManager(i)
248269     if ((checkCaller == checkCaller))
249270         then [StringEntry(keyFactoryConfig(), dataFactoryCfg(stakingContract, boostingContract, idoContract, teamContract, emissionContract, restContract, slpipageContract)), IntegerEntry(keyPriceDecimals(), priceDecimals)]
250271         else throw("Strict value is not equal to itself.")
251272     }
252273 
253274 
254275 
255276 @Callable(i)
256277 func constructorV2 (mathcherPub58Str) = {
257278     let checkCaller = mustManager(i)
258279     if ((checkCaller == checkCaller))
259280         then {
260281             let mathcerPub = addressFromPublicKey(fromBase58String(mathcherPub58Str))
261282             if ((mathcerPub == mathcerPub))
262283                 then [StringEntry(keyMatcherPub(), mathcherPub58Str)]
263284                 else throw("Strict value is not equal to itself.")
264285             }
265286         else throw("Strict value is not equal to itself.")
266287     }
267288 
268289 
269290 
270291 @Callable(i)
271292 func constructorV3 (daoContract,marketingContract,gwxRewardsContract,birdsContract) = {
272293     let checkCaller = mustManager(i)
273294     if ((checkCaller == checkCaller))
274295         then {
275296             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
276297 [StringEntry(keyFactoryConfig(), dataFactoryCfgV3(factoryCfg[1], factoryCfg[2], factoryCfg[3], factoryCfg[4], factoryCfg[5], factoryCfg[6], factoryCfg[7], daoContract, marketingContract, gwxRewardsContract, birdsContract))]
277298             }
278299         else throw("Strict value is not equal to itself.")
279300     }
280301 
281302 
282303 
283304 @Callable(i)
284305 func constructorV4 (legacyFactoryContract,legacyPools) = {
285306     let checkCaller = mustManager(i)
286307     if ((checkCaller == checkCaller))
287308         then [StringEntry(keyLegacyFactoryContract(), legacyFactoryContract), StringEntry(keyLegacyPools(), makeString(legacyPools, SEP))]
288309         else throw("Strict value is not equal to itself.")
289310     }
290311 
291312 
292313 
293314 @Callable(i)
315+func constructorV5 (assetsStoreContract) = {
316+    let checkCaller = mustManager(i)
317+    if ((checkCaller == checkCaller))
318+        then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
319+        else throw("Strict value is not equal to itself.")
320+    }
321+
322+
323+
324+@Callable(i)
294325 func setManager (pendingManagerPublicKey) = {
295326     let checkCaller = mustManager(i)
296327     if ((checkCaller == checkCaller))
297328         then {
298329             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
299330             if ((checkManagerPublicKey == checkManagerPublicKey))
300331                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
301332                 else throw("Strict value is not equal to itself.")
302333             }
303334         else throw("Strict value is not equal to itself.")
304335     }
305336 
306337 
307338 
308339 @Callable(i)
309340 func confirmManager () = {
310341     let pm = pendingManagerPublicKeyOrUnit()
311342     let hasPM = if (isDefined(pm))
312343         then true
313344         else throw("No pending manager")
314345     if ((hasPM == hasPM))
315346         then {
316347             let checkPM = if ((i.callerPublicKey == value(pm)))
317348                 then true
318349                 else throw("You are not pending manager")
319350             if ((checkPM == checkPM))
320351                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
321352                 else throw("Strict value is not equal to itself.")
322353             }
323354         else throw("Strict value is not equal to itself.")
324355     }
325356 
326357 
327358 
328359 @Callable(i)
360+func setAdmins (adminPubKeys) = {
361+    let checkCaller = mustManager(i)
362+    if ((checkCaller == checkCaller))
363+        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
364+        else throw("Strict value is not equal to itself.")
365+    }
366+
367+
368+
369+@Callable(i)
329370 func activateNewPool (poolAddress,amountAssetStr,priceAssetStr,lpAssetName,lpAssetDescr,poolWeight,poolType) = {
330-    let checkCaller = mustManager(i)
371+    let checkCaller = mustAdmin(i)
331372     if ((checkCaller == checkCaller))
332373         then if (isDefined(getString(keyMappingPoolContractAddressToPoolAssets(poolAddress))))
333374             then throw((("Pool address " + poolAddress) + " already registered."))
334375             else {
335376                 let internalAmountAssetData = getInternalAssetIdOrCreate(amountAssetStr, 1)
336377                 let internalAmountAssetId = internalAmountAssetData._1
337378                 let internalPriceAssetData = getInternalAssetIdOrCreate(priceAssetStr, if (internalAmountAssetData._3)
338379                     then 2
339380                     else 1)
340381                 let internalPriceAssetId = internalPriceAssetData._1
341382                 let poolAccountScriptHash = valueOrErrorMessage(scriptHash(addressFromStringValue(poolAddress)), ("No script has been found on pool account " + poolAddress))
342383                 let ethalonPoolAccountScriptHash = getBinaryValue(keyPoolScriptHash())
343384                 let poolConfig = getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)))
344385                 if (isDefined(poolConfig))
345386                     then throw((((("Pool " + amountAssetStr) + "/") + priceAssetStr) + " has already been activated."))
346387                     else {
347388                         let poolConfigValue = value(getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId))))
348389                         let amountAssetsDecimals = if ((amountAssetStr == "WAVES"))
349390                             then decimalsMultPrice
350391                             else pow(10, 0, value(assetInfo(fromBase58String(amountAssetStr))).decimals, 0, 0, DOWN)
351392                         let priceAssetsDecimals = if ((priceAssetStr == "WAVES"))
352393                             then decimalsMultPrice
353394                             else pow(10, 0, value(assetInfo(fromBase58String(priceAssetStr))).decimals, 0, 0, DOWN)
354395                         let lpAssetIssueAction = Issue(lpAssetName, lpAssetDescr, 1, 8, true)
355396                         let lpAssetId = calculateAssetId(lpAssetIssueAction)
356397                         let lpAssetIdStr = toBase58String(lpAssetId)
357398                         let poolActivateInvokeResult = invoke(addressFromStringValue(poolAddress), "activate", [amountAssetStr, priceAssetStr], nil)
358399                         if ((poolActivateInvokeResult == poolActivateInvokeResult))
359400                             then if ((poolActivateInvokeResult != "success"))
360401                                 then throw("Pool initialisation error happened.")
361-                                else $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(keyMappingPoolContracToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight), StringEntry(keyLpTokensList(), createLpTokensListEntry(lpAssetIdStr))]), "success")
402+                                else {
403+                                    let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract()))
404+                                    let isAmountAssetVerified =                                     match invoke(assetsStoreContract, "isVerifiedREADONLY", [amountAssetStr], nil) {
405+                                        case b: Boolean => 
406+                                            b
407+                                        case _ => 
408+                                            false
409+                                    }
410+                                    let createOrUpdateLpAssetInv = invoke(assetsStoreContract, "createOrUpdate", [lpAssetIdStr, lpAssetName, "", isAmountAssetVerified], nil)
411+                                    if ((createOrUpdateLpAssetInv == createOrUpdateLpAssetInv))
412+                                        then {
413+                                            let addPoolsLpLabelInv = invoke(assetsStoreContract, "addLabel", [lpAssetIdStr, labelPoolsLp], nil)
414+                                            if ((addPoolsLpLabelInv == addPoolsLpLabelInv))
415+                                                then {
416+                                                    let addAssetsLinkInv = invoke(assetsStoreContract, "addAssetsLink", [amountAssetStr, priceAssetStr, lpAssetIdStr], nil)
417+                                                    if ((addAssetsLinkInv == addAssetsLinkInv))
418+                                                        then {
419+                                                            let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
420+                                                            if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
421+                                                                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(keyMappingPoolContracToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight), StringEntry(keyLpTokensList(), createLpTokensListEntry(lpAssetIdStr))]), lpAssetIdStr)
422+                                                                else throw("Strict value is not equal to itself.")
423+                                                            }
424+                                                        else throw("Strict value is not equal to itself.")
425+                                                    }
426+                                                else throw("Strict value is not equal to itself.")
427+                                            }
428+                                        else throw("Strict value is not equal to itself.")
429+                                    }
362430                             else throw("Strict value is not equal to itself.")
363431                         }
364432                 }
365433         else throw("Strict value is not equal to itself.")
366434     }
367435 
368436 
369437 
370438 @Callable(i)
371439 func managePool (poolAddress,newStatus) = {
372440     let checkCaller = mustManager(i)
373441     if ((checkCaller == checkCaller))
374442         then {
375443             let poolConfig = getPoolConfig(poolAddress)
376444             let poolStatus = poolConfig[idxPoolStatus]
377445             let lpAssetIdStr = poolConfig[idxPoolLPAssetId]
378446             let amountAssetStr = poolConfig[idxAmtAssetId]
379447             let priceAssetStr = poolConfig[idxPriceAssetId]
380448             let amountAssetsDecimals = parseIntValue(poolConfig[idxAmtAssetDcm])
381449             let priceAssetsDecimals = parseIntValue(poolConfig[idxPriceAssetDcm])
382450             let internalAmountAssetId = parseIntValue(poolConfig[idxIAmtAssetId])
383451             let internalPriceAssetId = parseIntValue(poolConfig[idxIPriceAssetId])
384452             let lpAssetDcm = parseIntValue(poolConfig[idxLPAssetDcm])
385453             let poolType = poolConfig[idxPoolType]
386454 [StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(newStatus), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, lpAssetDcm, poolType))]
387455             }
388456         else throw("Strict value is not equal to itself.")
389457     }
390458 
391459 
392460 
393461 @Callable(i)
394462 func emit (amountToEmit) = {
395463     let caller = i.caller
396464     let originCaller = i.originCaller
397465     let lpAssetRequested = valueOrErrorMessage(getString(keyMappingPoolContracToLPAsset(toString(caller))), "Invalid LP address called me.")
398466     let lpAsset = fromBase58String(lpAssetRequested)
399467     let legacyPools = split(valueOrElse(getString(keyLegacyPools()), EMPTY), SEP)
400468     let legacyFactoryContract = addressFromStringValue(valueOrErrorMessage(getString(keyLegacyFactoryContract()), "Legacy factory contract does not exists."))
401469     if ((0 >= amountToEmit))
402470         then nil
403471         else if (containsElement(legacyPools, toString(caller)))
404472             then $Tuple2(nil, legacyFactoryContract)
405473             else $Tuple2([Reissue(lpAsset, amountToEmit, true), ScriptTransfer(i.caller, amountToEmit, lpAsset)], "success")
406474     }
407475 
408476 
409477 
410478 @Callable(i)
411479 func burn (amountToBurn) = {
412480     let caller = i.caller
413481     let originCaller = i.originCaller
414482     let payment = value(i.payments[0])
415483     let paymentAmount = value(payment.amount)
416484     let inAmountAssetId = toBase58String(value(payment.assetId))
417485     let lpAssetRequestedForBurning = valueOrErrorMessage(getString(keyMappingPoolContracToLPAsset(toString(caller))), "Invalid LP address called me.")
418486     if ((inAmountAssetId != lpAssetRequestedForBurning))
419487         then throw("Invalid asset passed.")
420488         else if ((amountToBurn != paymentAmount))
421489             then throw("Invalid amount passed.")
422490             else {
423491                 let lpAsset = fromBase58String(lpAssetRequestedForBurning)
424492                 $Tuple2([Burn(lpAsset, amountToBurn)], "success")
425493                 }
426494     }
427495 
428496 
429497 
430498 @Callable(i)
431499 func modifyWeights (btcPoolAddress,ethPoolAddress,ethBtcPoolAddress,usdcUsdtPoolAddress) = {
432500     let checkCaller = mustManager(i)
433501     if ((checkCaller == checkCaller))
434502         then {
435503             let ethBtcWeightNew = ((5 * POOLWEIGHTMULT) / 100)
436504             let usdcUsdtWeightNew = ((5 * POOLWEIGHTMULT) / 100)
437505             let weightDecrement = ((5 * POOLWEIGHTMULT) / 100)
438506             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
439507             let stakingDapp = getStakingAddressOrFail(factoryCfg)
440508             let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
441509             let btcWeightKEY = keyPoolToWeight(btcPoolAddress)
442510             let ethWeightKEY = keyPoolToWeight(ethPoolAddress)
443511             let ethBtcWeightKEY = keyPoolToWeight(ethBtcPoolAddress)
444512             let usdcUsdtWeightKEY = keyPoolToWeight(usdcUsdtPoolAddress)
445513             let btcWeight = getIntOrFail(btcWeightKEY)
446514             let ethWeight = getIntOrFail(ethWeightKEY)
447515             let btcWeightNew = (btcWeight - weightDecrement)
448516             let ethWeightNew = (ethWeight - weightDecrement)
449517             if ((0 >= btcWeightNew))
450518                 then throw(("invalid btcWeightNew: " + toString(btcWeightNew)))
451519                 else if ((0 >= ethWeightNew))
452520                     then throw(("invalid ethWeightNew: " + toString(ethWeightNew)))
453521                     else {
454522                         let btcLpAssetIdStr = getStringOrFail(keyMappingPoolContracToLPAsset(btcPoolAddress))
455523                         let ethLpAssetIdStr = getStringOrFail(keyMappingPoolContracToLPAsset(ethPoolAddress))
456524                         let ethBtcLpAssetIdStr = getStringOrFail(keyMappingPoolContracToLPAsset(ethBtcPoolAddress))
457525                         let usdcUsdtLpAssetIdStr = getStringOrFail(keyMappingPoolContracToLPAsset(usdcUsdtPoolAddress))
458526                         let onModifyWeightBtc = invoke(stakingDapp, "onModifyWeight", [btcLpAssetIdStr, btcPoolAddress], nil)
459527                         if ((onModifyWeightBtc == onModifyWeightBtc))
460528                             then {
461529                                 let onModifyWeightEth = invoke(stakingDapp, "onModifyWeight", [ethLpAssetIdStr, ethPoolAddress], nil)
462530                                 if ((onModifyWeightEth == onModifyWeightEth))
463531                                     then {
464532                                         let onModifyWeightEthBtc = invoke(stakingDapp, "onModifyWeight", [ethBtcLpAssetIdStr, ethBtcPoolAddress], nil)
465533                                         if ((onModifyWeightEthBtc == onModifyWeightEthBtc))
466534                                             then {
467535                                                 let onModifyWeightUsdcUsdt = invoke(stakingDapp, "onModifyWeight", [usdcUsdtLpAssetIdStr, usdcUsdtPoolAddress], nil)
468536                                                 if ((onModifyWeightUsdcUsdt == onModifyWeightUsdcUsdt))
469537                                                     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)]
470538                                                     else throw("Strict value is not equal to itself.")
471539                                                 }
472540                                             else throw("Strict value is not equal to itself.")
473541                                         }
474542                                     else throw("Strict value is not equal to itself.")
475543                                 }
476544                             else throw("Strict value is not equal to itself.")
477545                         }
478546             }
479547         else throw("Strict value is not equal to itself.")
480548     }
481549 
482550 
483551 @Verifier(tx)
484552 func verify () = {
485553     let targetPublicKey =     match managerPublicKeyOrUnit() {
486554         case pk: ByteVector => 
487555             pk
488556         case _: Unit => 
489557             tx.senderPublicKey
490558         case _ => 
491559             throw("Match error")
492560     }
493561     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
494562     }
495563 
github/deemru/w8io/169f3d6 
55.86 ms ◑