wxdefi-423

ride/factory_v2.ride

@@ -1030,6 +1030,89 @@ func deletePool(poolContractAddress: String) = {
   ]
 }
 
+# USE WITH CAUTION
+@Callable(i)
+func invert(poolAddressStr: String) = {
+  strict checks = [
+    i.mustManager()
+  ]
+
+  let userPoolsContract = keyUserPoolsContract().getStringValue().addressFromStringValue()
+  let votingEmissionContract = keyVotingEmissionContract().getStringValue().addressFromStringValue()
+  let poolAddress = poolAddressStr.addressFromStringValue()
+
+  let poolConfig = getPoolConfig(poolAddressStr)
+
+  let poolStatus = poolConfig[idxPoolStatus]
+  let lpAssetIdStr = poolConfig[idxPoolLPAssetId]
+  let amountAssetStr = poolConfig[idxAmtAssetId]
+  let priceAssetStr = poolConfig[idxPriceAssetId]
+  let amountAssetsDecimals = poolConfig[idxAmtAssetDcm].parseIntValue()
+  let priceAssetsDecimals = poolConfig[idxPriceAssetDcm].parseIntValue()
+  let internalAmountAssetId = poolConfig[idxIAmtAssetId].parseIntValue()
+  let internalPriceAssetId = poolConfig[idxIPriceAssetId].parseIntValue()
+  let lpAssetDcm = poolConfig[idxLPAssetDcm].parseIntValue()
+  let poolType = poolConfig[idxPoolType]
+
+  strict invs = [
+    poolAddress.invoke("invert", [], []),
+    votingEmissionContract.invoke("invert", [amountAssetStr, priceAssetStr], [])
+  ]
+
+  let wxEmission = this.getBoolean(keyWxEmission(amountAssetStr, priceAssetStr)).valueOrElse(false)
+  let wxEmissionActions = if (wxEmission) then [
+    DeleteEntry(keyWxEmission(amountAssetStr, priceAssetStr)),
+    BooleanEntry(keyWxEmission(priceAssetStr, amountAssetStr), wxEmission)
+  ] else []
+
+  (
+    [
+      StringEntry(
+        keyPoolConfig(internalPriceAssetId.toString(), internalAmountAssetId.toString()),
+        dataPoolCfg(
+          poolAddressStr,
+          poolStatus,
+          lpAssetIdStr,
+          priceAssetStr,
+          amountAssetStr,
+          priceAssetsDecimals,
+          amountAssetsDecimals,
+          internalPriceAssetId,
+          internalAmountAssetId,
+          lpAssetDcm,
+          poolType
+        )
+      ),
+      DeleteEntry(keyPoolConfig(internalAmountAssetId.toString(), internalPriceAssetId.toString())),
+      StringEntry(
+        keyMappingLpAssetToPoolAssets(lpAssetIdStr),
+        dataMappingPoolAssets(
+          internalPriceAssetId,
+          internalAmountAssetId
+        )
+      ),
+      DeleteEntry(keyMappingPoolAssetsToLpasset(internalAmountAssetId.toString(), internalPriceAssetId.toString())),
+      StringEntry(
+        keyMappingPoolAssetsToLpasset(internalPriceAssetId.toString(), internalAmountAssetId.toString()),
+        "%s__" + lpAssetIdStr
+      ),
+      StringEntry(
+        keyMappingPoolContractAddressToPoolAssets(poolAddressStr),
+        dataMappingPoolAssets(
+          internalPriceAssetId,
+          internalAmountAssetId
+        )
+      ),
+      DeleteEntry(keyMappingPoolAssetsToPoolContractAddress(internalAmountAssetId, internalPriceAssetId)),
+      StringEntry(
+        keyMappingPoolAssetsToPoolContractAddress(internalPriceAssetId, internalAmountAssetId),
+        poolAddressStr
+      )
+    ] ++ wxEmissionActions,
+    unit
+  )
+}
+
 @Verifier(tx)
 func verify() = {
   let targetPublicKey = match managerPublicKeyOrUnit() {

ride/lp.ride

@@ -1494,6 +1494,18 @@ func activate(amtAssetStr: String, priceAssetStr: String) = {
     }
 }
 
+@Callable(i)
+func invert() = {
+  strict checks = [
+    i.caller == factoryContract || throwErr("invalid caller")
+  ]
+
+  ([
+    StringEntry(aa(), cfgPriceAssetId.assetIdToString()),
+    StringEntry(pa(), cfgAmountAssetId.assetIdToString())
+  ], unit)
+}
+
 @Callable(i)
 func refreshKLp() = {
   let lastRefreshedBlockHeight = keyKLpRefreshedHeight.getInteger().valueOrElse(0)

ride/lp_stable.ride

@@ -1615,6 +1615,18 @@ func activate(amtAsStr: String, prAsStr: String) = {
     }
 }
 
+@Callable(i)
+func invert() = {
+  strict checks = [
+    i.caller == fca || throwErr("invalid caller")
+  ]
+
+  ([
+    StringEntry(aa(), cfgPriceAssetId.assetIdToString()),
+    StringEntry(pa(), cfgAmountAssetId.assetIdToString())
+  ], unit)
+}
+
 # API wrappers
 @Callable(i)
 func getPoolConfigWrapperREADONLY() = {

ride/voting_emission.ride

@@ -770,17 +770,42 @@ func isFinalizationInProgress() = {
 
 @Callable(i)
 func deletePool(amountAssetId: String, priceAssetId: String) = {
-  strict checkCaller = i.caller == factoryContract || i.mustManager() || "Permission denied".throwErr()
+  strict checkCaller = i.caller == factoryContract || i.caller == this || i.mustManager() || "Permission denied".throwErr()
 
   let listName = "pools"
   let pool = (amountAssetId, priceAssetId)
   let id = makeString([amountAssetId, priceAssetId], separator)
 
-  let actions = if (containsNode(listName, id)) then deleteNodeActions(listName, id) else []
+  let exists = containsNode(listName, id)
+  let actions = if (exists) then deleteNodeActions(listName, id) else []
 
-  [
-    DeleteEntry(keyInList(pool))
-  ] ++ actions
+  (
+    [
+      DeleteEntry(keyInList(pool))
+    ] ++ actions,
+    exists
+  )
+}
+
+@Callable(i)
+func invert(amountAssetId: String, priceAssetId: String) = {
+  strict checks = [
+    i.caller == factoryContract || throwErr("invalid caller")
+  ]
+
+  strict existed = this.invoke("deletePool", [amountAssetId, priceAssetId], []).exactAs[Boolean]
+
+  let pool = (priceAssetId, amountAssetId)
+  let inListActions = if (existed) then {
+    [
+      BooleanEntry(pool.keyInList(), true)
+    ] ++ poolsListName.insertNodeActions(pool.poolToString())
+  } else []
+
+  (
+    inListActions,
+    unit
+  )
 }
 
 @Verifier(tx)