w8 · tx · 35A···Niy

tx · 35A1BLqZ6g6LxFEZVA17Gd3VSYnGm8nz8EBTb7CxGNiy

3PCuHsTU58WKhCqotbcSwABvdPzqqVAbbTv:  -0.02900000 Waves

2023.01.26 19:59 [3487719] smart account 3PCuHsTU58WKhCqotbcSwABvdPzqqVAbbTv > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "35A1BLqZ6g6LxFEZVA17Gd3VSYnGm8nz8EBTb7CxGNiy",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1674752292184,
    "version": 1,
    "sender": "3PCuHsTU58WKhCqotbcSwABvdPzqqVAbbTv",
    "senderPublicKey": "HBWgh7DKPyzCnEXKJAJ5dKQ3jmPtMhGD78tt6jRdkV61",
    "proofs": [
        "2dGw9xyQPAC6mH7Zsd7qaEPBnvdbY9LnRXGWpmo4AFQTa2MANFi1REtcqPTNSE8Bh2XVCwm7so6rfGjRbY9wp17y"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3487719,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2jUHyDnAVMZMjqsUNufy6iCqQsaFWnswaGavPdUi2vvX
Next: 5WWHNtunneurhqK5AaN4Mu62P6zi6qgTAHxhmWwnQVjc

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

Old	New		Differences
1		-	{-# STDLIB_VERSION 5 #-}
	1	+	{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let SCALE8 = 8

Old	New		Differences
1		-	{-# STDLIB_VERSION 5 #-}
	1	+	{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let SCALE8 = 8
5	5
6	6		let MULT8 = 100000000
7	7
8	8		let SCALE18 = 18
9	9
10	10		let MULT18 = toBigInt(1000000000000000000)
11	11
12	12		let POOLWEIGHTMULT = MULT8
13	13
14	14		let GWXvirtualPOOL = "GWXvirtualPOOL"
15	15
16	16		let labelPoolsLp = "POOLS_LP"
17	17
18	18		let defaultSpread = 2000000
19	19
20	20		let decimalsMultPrice = ((100 * 1000) * 1000)
21	21
22	22		let SEP = "__"
23	23
24	24		let EMPTY = ""
25	25
26	26		let PoolActive = 1
27	27
28	28		let PoolPutDisabled = 2
29	29
30	30		let PoolMatcherDisabled = 3
31	31
32	32		let PoolShutdown = 4
33	33
34	34		let idxInternalAssetId = 1
35	35
36	36		let idxResutActions = 2
37	37
38	38		let idxIfAssetIdCalculationPerformed = 3
39	39
40	40		let idxPoolAddress = 1
41	41
42	42		let idxPoolStatus = 2
43	43
44	44		let idxPoolLPAssetId = 3
45	45
46	46		let idxAmtAssetId = 4
47	47
48	48		let idxPriceAssetId = 5
49	49
50	50		let idxAmtAssetDcm = 6
51	51
52	52		let idxPriceAssetDcm = 7
53	53
54	54		let idxIAmtAssetId = 8
55	55
56	56		let idxIPriceAssetId = 9
57	57
58	58		let idxLPAssetDcm = 10
59	59
60	60		let idxPoolType = 11
61	61
62	62		let poolLabelWxEmission = "WX_EMISSION"
63	63
64	64		let validPoolLabels = [poolLabelWxEmission]
65	65
66	66		func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
67	67
68	68
69	69		func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
70	70
71	71
72	72		func keyAllowedLpStableAddonScriptHash () = "%s__allowedLpStableAddonScriptHash"
73	73
74	74
75	75		func keyFactoryConfig () = "%s__factoryConfig"
76	76
77	77
78	78		func keyLpTokensList () = "%s__lpTokensList"
79	79
80	80
81	81		func keyPoolScriptHash () = "%s%s__pool__scriptHash"
82	82
83	83
84	84		func keyMatcherPub () = "%s%s__matcher__publicKey"
85	85
86	86
87	87		func keyLegacyFactoryContract () = "%s__legacyFactoryContract"
88	88
89	89
90	90		func keyLegacyPools () = "%s__legacyPools"
91	91
92	92
93	93		func keyManagerPublicKey () = "%s__managerPublicKey"
94	94
95	95
96	96		func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
97	97
98	98
99	99		func keyAdminPubKeys () = "%s__adminPubKeys"
100	100
101	101
102	102		func keyAssetsStoreContract () = "%s__assetsStoreContract"
103	103
104	104
105	105		func keyVotingEmissionContract () = "%s__votingEmissionContract"
106	106
107	107
108	108		func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
109	109
110	110
111	111		func keyPriceDecimals () = "%s__priceDecimals"
112	112
113	113
114	114		func keyAllPoolsShutdown () = "%s__shutdown"
115	115
116	116
117	117		func keyNextInternalAssetId () = "%s__nextInternalAssetId"
118	118
119	119
120	120		func keyPoolToWeight (poolAddress) = ("%s%s__poolWeight__" + poolAddress)
121	121
122	122
123	123		func keyPoolToWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
124	124
125	125
126	126		func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
127	127
128	128
129	129		func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
130	130
131	131
132	132		func keyPoolConfig (amountAssetInternal,priceAssetInternal) = (((("%d%d%s__" + amountAssetInternal) + "__") + priceAssetInternal) + "__config")
133	133
134	134
135	135		func keyPoolOneTokenOperationsDisabled (assetsInternal) = {
136	136		let $t036323694 = assetsInternal
137	137		let amountAssetInternal = $t036323694._1
138	138		let priceAssetInternal = $t036323694._2
139	139		makeString(["%d%d%s", toString(amountAssetInternal), toString(priceAssetInternal), "oneTokenOperationsDisabled"], SEP)
140	140		}
141	141
142	142
143	143		func keyAllPoolsOneTokenOperationsDisabled () = makeString(["%s", "oneTokenOperationsDisabled"], SEP)
144	144
145	145
146	146		func keyMappingLpAssetToPoolAssets (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2Pool")
147	147
148	148
149	149		func keyMappingPoolAssetsToLpasset (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + internalAmountAssetIdStr) + "__") + internalPriceAssetIdStr) + "__mappings__PoolAssets2LpAsset")
150	150
151	151
152	152		func keyPoolSpread (poolAddress) = ("%s%s__spread__" + poolAddress)
153	153
154	154
155	155		func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
156	156
157	157
158	158		func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
159	159
160	160
161	161		func keyMappingPoolContractToLPAsset (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
162	162
163	163
164	164		func keyMappingPoolLPAssetToPoolContractAddress (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2PoolContract")
165	165
166	166
167	167		func keyWxEmission (amountAssetId,priceAssetId) = ((("%s%s%s__wxEmission__" + amountAssetId) + "__") + priceAssetId)
168	168
169	169
170	170		func keyInFee (poolAddress) = ("%s%s__inFee__" + poolAddress)
171	171
172	172
173	173		func keyInFeeDefault () = "%s__inFeeDefault"
174	174
175	175
176	176		func keyOutFee (poolAddress) = ("%s%s__outFee__" + poolAddress)
177	177
178	178
179	179		func keyOutFeeDefault () = "%s__outFeeDefault"
180	180
181	181
182	182		func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
183	183
184	184
185	185		func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
186	186
187	187
188	188		func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
189	189
190	190
191	191		let IdxFactoryCfgStakingDapp = 1
192	192
193	193		let IdxFactoryCfgBoostingDapp = 2
194	194
195	195		let IdxFactoryCfgIdoDapp = 3
196	196
197	197		let IdxFactoryCfgTeamDapp = 4
198	198
199	199		let IdxFactoryCfgEmissionDapp = 5
200	200
201	201		let IdxFactoryCfgRestDapp = 6
202	202
203	203		let IdxFactoryCfgSlippageDapp = 7
204	204
205	205		let IdxFactoryCfgDaoDapp = 8
206	206
207	207		let IdxFactoryCfgMarketingDapp = 9
208	208
209	209		let IdxFactoryCfgGwxRewardDapp = 10
210	210
211	211		let IdxFactoryCfgBirdsDapp = 11
212	212
213	213		func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
214	214
215	215
216	216		func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
217	217
218	218
219	219		func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
220	220
221	221
222	222		func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
223	223
224	224
225	225		func getPriceAssets () = match getString(keyPriceAssets()) {
226	226		case s: String =>
227	227		if ((size(s) == 0))
228	228		then nil
229	229		else split(s, SEP)
230	230		case _ =>
231	231		nil
232	232		}
233	233
234	234
235	235		func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
236	236		case s: String =>
237	237		fromBase58String(s)
238	238		case _: Unit =>
239	239		unit
240	240		case _ =>
241	241		throw("Match error")
242	242		}
243	243
244	244
245	245		func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
246	246		case s: String =>
247	247		fromBase58String(s)
248	248		case _: Unit =>
249	249		unit
250	250		case _ =>
251	251		throw("Match error")
252	252		}
253	253
254	254
255	255		let permissionDeniedError = throw("Permission denied")
256	256
257	257		func mustThis (i) = if ((i.caller == this))
258	258		then true
259	259		else permissionDeniedError
260	260
261	261
262	262		func mustManager (i) = match managerPublicKeyOrUnit() {
263	263		case pk: ByteVector =>
264	264		if ((i.callerPublicKey == pk))
265	265		then true
266	266		else permissionDeniedError
267	267		case _: Unit =>
268	268		mustThis(i)
269	269		case _ =>
270	270		throw("Match error")
271	271		}
272	272
273	273
274	274		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)
275	275
276	276
277	277		func dataFactoryCfg (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract) = makeString(["%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract], SEP)
278	278
279	279
280	280		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)
281	281
282	282
283	283		func dataMappingPoolAssets (internalAmountAssetStr,internalPriceAssetStr) = makeString(["%d%d", toString(internalAmountAssetStr), toString(internalPriceAssetStr)], SEP)
284	284
285	285
286	286		func getPoolConfig (poolAddress) = {
287	287		let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
288	288		let amountAssetInternal = poolAssets[1]
289	289		let priceAssetInternal = poolAssets[2]
290	290		split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
291	291		}
292	292
293	293
294	294		func getInternalAssetIdOrCreate (assetIdStr,incrementor) = {
295	295		let internalAssetId = valueOrElse(getInteger(this, keyMappingsBaseAsset2internalId(assetIdStr)), 0)
296	296		let currentIndexOfInternalId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
297	297		let result = if ((internalAssetId == 0))
298	298		then {
299	299		let newInternalAssetId = (currentIndexOfInternalId + incrementor)
300	300		$Tuple3(newInternalAssetId, [IntegerEntry(keyNextInternalAssetId(), newInternalAssetId), IntegerEntry(keyMappingsBaseAsset2internalId(assetIdStr), newInternalAssetId), StringEntry(keyMappingsInternal2baseAssetId(newInternalAssetId), assetIdStr)], true)
301	301		}
302	302		else $Tuple3(internalAssetId, nil, false)
303	303		result
304	304		}
305	305
306	306
307	307		func mustAdmin (i) = {
308	308		let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
309	309		if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
310	310		then true
311	311		else {
312	312		let isManager = mustManager(i)
313	313		if ((isManager == isManager))
314	314		then true
315	315		else throw("Strict value is not equal to itself.")
316	316		}
317	317		}
318	318
319	319
320	320		func intOrDefaultOrFallback (key,keyDefault,valueFallback) = valueOrElse(getInteger(this, key), valueOrElse(getInteger(this, keyDefault), valueFallback))
321	321
322	322
323	323		@Callable(i)
324	324		func constructor (stakingContract,boostingContract,idoContract,teamContract,emissionContract,restContract,slpipageContract,priceDecimals) = {
325	325		let checkCaller = mustManager(i)
326	326		if ((checkCaller == checkCaller))
327	327		then [StringEntry(keyFactoryConfig(), dataFactoryCfg(stakingContract, boostingContract, idoContract, teamContract, emissionContract, restContract, slpipageContract)), IntegerEntry(keyPriceDecimals(), priceDecimals)]
328	328		else throw("Strict value is not equal to itself.")
329	329		}
330	330
331	331
332	332
333	333		@Callable(i)
334	334		func constructorV2 (mathcherPub58Str) = {
335	335		let checkCaller = mustManager(i)
336	336		if ((checkCaller == checkCaller))
337	337		then {
338	338		let mathcerPub = addressFromPublicKey(fromBase58String(mathcherPub58Str))
339	339		if ((mathcerPub == mathcerPub))
340	340		then [StringEntry(keyMatcherPub(), mathcherPub58Str)]
341	341		else throw("Strict value is not equal to itself.")
342	342		}
343	343		else throw("Strict value is not equal to itself.")
344	344		}
345	345
346	346
347	347
348	348		@Callable(i)
349	349		func constructorV3 (daoContract,marketingContract,gwxRewardsContract,birdsContract) = {
350	350		let checkCaller = mustManager(i)
351	351		if ((checkCaller == checkCaller))
352	352		then {
353	353		let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
354	354		[StringEntry(keyFactoryConfig(), dataFactoryCfgV3(factoryCfg[1], factoryCfg[2], factoryCfg[3], factoryCfg[4], factoryCfg[5], factoryCfg[6], factoryCfg[7], daoContract, marketingContract, gwxRewardsContract, birdsContract))]
355	355		}
356	356		else throw("Strict value is not equal to itself.")
357	357		}
358	358
359	359
360	360
361	361		@Callable(i)
362	362		func constructorV4 (legacyFactoryContract,legacyPools) = {
363	363		let checkCaller = mustManager(i)
364	364		if ((checkCaller == checkCaller))
365	365		then [StringEntry(keyLegacyFactoryContract(), legacyFactoryContract), StringEntry(keyLegacyPools(), makeString(legacyPools, SEP))]
366	366		else throw("Strict value is not equal to itself.")
367	367		}
368	368
369	369
370	370
371	371		@Callable(i)
372	372		func constructorV5 (assetsStoreContract) = {
373	373		let checkCaller = mustManager(i)
374	374		if ((checkCaller == checkCaller))
375	375		then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
376	376		else throw("Strict value is not equal to itself.")
377	377		}
378	378
379	379
380	380
381	381		@Callable(i)
382	382		func constructorV6 (votingEmissionContract,priceAssets) = {
383	383		let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
384	384		then true
385	385		else "invalid voting emission contract address"]
386	386		if ((cheks == cheks))
387	387		then [StringEntry(keyVotingEmissionContract(), votingEmissionContract), StringEntry(keyPriceAssets(), makeString(priceAssets, SEP))]
388	388		else throw("Strict value is not equal to itself.")
389	389		}
390	390
391	391
392	392
393	393		@Callable(i)
394	394		func setManager (pendingManagerPublicKey) = {
395	395		let checkCaller = mustManager(i)
396	396		if ((checkCaller == checkCaller))
397	397		then {
398	398		let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
399	399		if ((checkManagerPublicKey == checkManagerPublicKey))
400	400		then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
401	401		else throw("Strict value is not equal to itself.")
402	402		}
403	403		else throw("Strict value is not equal to itself.")
404	404		}
405	405
406	406
407	407
408	408		@Callable(i)
409	409		func confirmManager () = {
410	410		let pm = pendingManagerPublicKeyOrUnit()
411	411		let hasPM = if (isDefined(pm))
412	412		then true
413	413		else throw("No pending manager")
414	414		if ((hasPM == hasPM))
415	415		then {
416	416		let checkPM = if ((i.callerPublicKey == value(pm)))
417	417		then true
418	418		else throw("You are not pending manager")
419	419		if ((checkPM == checkPM))
420	420		then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
421	421		else throw("Strict value is not equal to itself.")
422	422		}
423	423		else throw("Strict value is not equal to itself.")
424	424		}
425	425
426	426
427	427
428	428		@Callable(i)
429	429		func setAdmins (adminPubKeys) = {
430	430		let checkCaller = mustManager(i)
431	431		if ((checkCaller == checkCaller))
432	432		then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
433	433		else throw("Strict value is not equal to itself.")
434	434		}
435	435
436	436
437	437
438	438		@Callable(i)
439	439		func activateNewPool (poolAddress,amountAssetStr,priceAssetStr,lpAssetName,lpAssetDescr,poolWeight,poolType,logo) = {
440	440		let checkCaller = mustAdmin(i)
441	441		if ((checkCaller == checkCaller))
442	442		then if (isDefined(getString(keyMappingPoolContractAddressToPoolAssets(poolAddress))))
443	443		then throw((("Pool address " + poolAddress) + " already registered."))
444	444		else {
445	445		let internalAmountAssetData = getInternalAssetIdOrCreate(amountAssetStr, 1)
446	446		let internalAmountAssetId = internalAmountAssetData._1
447	447		let internalPriceAssetData = getInternalAssetIdOrCreate(priceAssetStr, if (internalAmountAssetData._3)
448	448		then 2
449	449		else 1)
450	450		let internalPriceAssetId = internalPriceAssetData._1
451	451		let poolAccountScriptHash = valueOrErrorMessage(scriptHash(addressFromStringValue(poolAddress)), ("No script has been found on pool account " + poolAddress))
452	452		let ethalonPoolAccountScriptHash = getBinaryValue(keyPoolScriptHash())
453	453		let poolConfig = getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)))
454	454		if (isDefined(poolConfig))
455	455		then throw((((("Pool " + amountAssetStr) + "/") + priceAssetStr) + " has already been activated."))
456	456		else {
457	457		let poolConfigValue = value(getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId))))
458	458		let amountAssetsDecimals = if ((amountAssetStr == "WAVES"))
459	459		then decimalsMultPrice
460	460		else pow(10, 0, value(assetInfo(fromBase58String(amountAssetStr))).decimals, 0, 0, DOWN)
461	461		let priceAssetsDecimals = if ((priceAssetStr == "WAVES"))
462	462		then decimalsMultPrice
463	463		else pow(10, 0, value(assetInfo(fromBase58String(priceAssetStr))).decimals, 0, 0, DOWN)
464	464		let lpAssetIssueAction = Issue(lpAssetName, lpAssetDescr, 1, 8, true)
465	465		let lpAssetId = calculateAssetId(lpAssetIssueAction)
466	466		let lpAssetIdStr = toBase58String(lpAssetId)
467	467		let poolActivateInvokeResult = invoke(addressFromStringValue(poolAddress), "activate", [amountAssetStr, priceAssetStr], nil)
468	468		if ((poolActivateInvokeResult == poolActivateInvokeResult))
469	469		then if ((poolActivateInvokeResult != "success"))
470	470		then throw("Pool initialisation error happened.")
471	471		else {
472	472		let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract()))
473	473		let createOrUpdateLpAssetInv = invoke(assetsStoreContract, "createOrUpdate", [lpAssetIdStr, lpAssetName, false], nil)
474	474		if ((createOrUpdateLpAssetInv == createOrUpdateLpAssetInv))
475	475		then {
476	476		let addPoolsLpLabelInv = invoke(assetsStoreContract, "addLabel", [lpAssetIdStr, labelPoolsLp], nil)
477	477		if ((addPoolsLpLabelInv == addPoolsLpLabelInv))
478	478		then {
479	479		let setLogoInv = invoke(assetsStoreContract, "setLogo", [lpAssetIdStr, logo], nil)
480	480		if ((setLogoInv == setLogoInv))
481	481		then {
482	482		let addAssetsLinkInv = invoke(assetsStoreContract, "addAssetsLink", [amountAssetStr, priceAssetStr, lpAssetIdStr], nil)
483	483		if ((addAssetsLinkInv == addAssetsLinkInv))
484	484		then {
485	485		let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
486	486		if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
487	487		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)
488	488		else throw("Strict value is not equal to itself.")
489	489		}
490	490		else throw("Strict value is not equal to itself.")
491	491		}
492	492		else throw("Strict value is not equal to itself.")
493	493		}
494	494		else throw("Strict value is not equal to itself.")
495	495		}
496	496		else throw("Strict value is not equal to itself.")
497	497		}
498	498		else throw("Strict value is not equal to itself.")
499	499		}

github/deemru/w8io/3ef1775 
98.91 ms ◑