[Fix] Osmosis - Continuously creating position on amm-LP strategy

src/chains/osmosis/osmosis.controllers.ts

@@ -1,6 +1,4 @@
-
-import {
-  HttpException,
+import {  HttpException,
   LOAD_WALLET_ERROR_CODE,
   LOAD_WALLET_ERROR_MESSAGE,
   PRICE_FAILED_ERROR_CODE,
@@ -673,29 +671,29 @@ export class OsmosisController {
       if (req.txHash){
         const transaction = await osmosis.getTransaction(req.txHash);
         const currentBlock = await osmosis.getCurrentBlockNumber();
-
+        const decoder = new TextDecoder();
         //@ts-ignore cosmojs models again
         var pool_id = undefined;
         var position_id = undefined;
         //@ts-ignore cosmojs models again
-        if (transaction.txResponse.logs){
-        //@ts-ignore cosmojs models again
-          transaction.txResponse.logs.forEach((log) => {
+        if (transaction.txResponse.events){
         //@ts-ignore cosmojs models again
-            const create_position_event = log.events.find(({ type }) => type === 'create_position');
+            const create_position_event = transaction.txResponse.events.find(({ type }) => type === 'create_position');
             if (create_position_event){
-        //@ts-ignore cosmojs models again
-              const pool_id_attribute = create_position_event.attributes.find(({ key }) => key === 'pool_id');
-              if (pool_id_attribute){
-                pool_id = pool_id_attribute.value
-              }
-        //@ts-ignore cosmojs models again
-              const position_id_attribute = create_position_event.attributes.find(({ key }) => key === 'position_id');
-              if (position_id_attribute){
-                position_id = position_id_attribute.value
-              }
-            }
-          })
+              //@ts-ignore cosmojs models again
+              create_position_event.attributes.forEach(attribute => {
+                const key = decoder.decode(attribute.key);
+                const value = decoder.decode(attribute.value);
+
+                if (key === 'pool_id'){
+                  pool_id = value;
+                }
+
+                if (key === 'position_id'){
+                  position_id = value;
+                }
+              });
+          }
         }
         var tokenId = position_id;
         if (position_id == undefined){

src/chains/osmosis/osmosis.ts

@@ -1,5 +1,4 @@
 // OSMO message composer classes don't quite match up with what the RPC/Go backend actually accepts.
-
 import { CosmosWallet, CosmosAsset, CosmosTokenValue, CosmosBase } from '../../chains/cosmos/cosmos-base'; 
 import { OsmosisController } from './osmosis.controllers';
 import BigNumber from 'bignumber.js';
@@ -51,7 +50,7 @@ import { Pool as CLPool } from 'osmo-query/dist/codegen/osmosis/concentrated-liq
 import { TradeInfo } from './osmosis.controllers';
 import { HttpException, TRADE_FAILED_ERROR_CODE, TRADE_FAILED_ERROR_MESSAGE, GAS_LIMIT_EXCEEDED_ERROR_MESSAGE, GAS_LIMIT_EXCEEDED_ERROR_CODE, AMOUNT_LESS_THAN_MIN_AMOUNT_ERROR_MESSAGE, AMOUNT_LESS_THAN_MIN_AMOUNT_ERROR_CODE } from '../../services/error-handler';
 import { extendPool, filterPoolsSwap, filterPoolsLP, filterPoolsSwapAndLP } from './osmosis.lp.utils';
-import { fetchFees, findTickForPrice, tickToPrice } from './osmosis.utils';
+import { fetchFees, findTickForPrice, tickToPrice, calculatePriceToTick } from './osmosis.utils';
 import { getImperatorPriceHash } from './osmosis.prices';
 import { GasPrice, calculateFee, setupIbcExtension, SigningStargateClient, AminoTypes } from '@cosmjs/stargate';
 import { CosmWasmClient } from "@cosmjs/cosmwasm-stargate";
@@ -1361,8 +1360,12 @@ export class Osmosis extends CosmosBase implements Cosmosish{
           tokenMinAmount1 = token1_bignumber.shiftedBy(this.getExponentByBase(token1.base)).multipliedBy(100-slippage).dividedBy(100).integerValue(BigNumber.ROUND_CEIL)
         }
 
-        const lowerTick = findTickForPrice(req.lowerPrice!, pool.exponentAtPriceOne, pool.tickSpacing, true) // pool.currentTick, 
-        const upperTick = findTickForPrice(req.upperPrice!, pool.exponentAtPriceOne, pool.tickSpacing, false)
+        // FIXME: The calculation of lowerTick and upperTick is not correct for the case where price is less than 1
+        const lowerTick = calculatePriceToTick(req.lowerPrice!, pool.exponentAtPriceOne, pool.tickSpacing, true) // pool.currentTick, 
+        const upperTick = calculatePriceToTick(req.upperPrice!, pool.exponentAtPriceOne, pool.tickSpacing, false)
+
+        console.log('lowerTick', lowerTick)
+        console.log('upperTick', upperTick)
 
         var tokenMinAmount0_final = tokenMinAmount0.toString()
         var tokenMinAmount1_final = tokenMinAmount1.toString()
@@ -2266,7 +2269,7 @@ export class Osmosis extends CosmosBase implements Cosmosish{
               countTotal: false,
               reverse: false,
             },
-            poolId: final_poolId.toString()
+            poolId: BigInt(final_poolId)
           })
           clPositions = clPositionsContainer.positions
         } catch (error) {
@@ -2290,7 +2293,6 @@ export class Osmosis extends CosmosBase implements Cosmosish{
         owner: address,
       });
       const lockedCoins: Coin[] = lockedCoinsContainer.lockedCoins ? lockedCoinsContainer.lockedCoins : []
-
       // RETURN TYPES:
       // concentrated-liquidity/pool || cosmwasmpool/v1beta1/model/pool || gamm/pool-models/balancer/balancerPool || gamm/pool-models/stableswap/stableswap_pool
       const poolsContainer = await this._provider.osmosis.poolmanager.v1beta1.allPools({});
@@ -2351,17 +2353,23 @@ export class Osmosis extends CosmosBase implements Cosmosish{
             }
           }
         });
+        const clPositionPool = extendedPools.find((pl) => pl.id.toString() === clPosition.position.poolId.toString());
+        const exponentToken0 = this.getExponentByBase(clPosition.asset0.denom)
+        const exponentToken1 = this.getExponentByBase(clPosition.asset1.denom)
+        // @ts-ignore
+        const lowerPrice = tickToPrice(exponentToken0, exponentToken1, clPosition.position.lowerTick.toString(), clPositionPool.exponentAtPriceOne.toString())
+        // @ts-ignore
+        const upperPrice = tickToPrice(exponentToken0, exponentToken1, clPosition.position.upperTick.toString(), clPositionPool.exponentAtPriceOne.toString())
 
         returnObj.token0 = clPosition.asset0.denom;
         returnObj.token1 = clPosition.asset1.denom;
-        returnObj.amount0 = clPosition.asset0.amount;
-        returnObj.amount1 = clPosition.asset1.amount;
-        returnObj.lowerPrice = clPosition.position.lowerTick.toString();
-        returnObj.upperPrice = clPosition.position.upperTick.toString();
+        returnObj.amount0 = (parseFloat(clPosition.asset0.amount) / Math.pow(10, exponentToken0)).toString();
+        returnObj.amount1 = (parseFloat(clPosition.asset1.amount) / Math.pow(10, exponentToken1)).toString();
+        returnObj.lowerPrice = lowerPrice.toString();
+        returnObj.upperPrice = upperPrice.toString();
         returnObj.poolShares = clPosition.position.liquidity
-        returnObj.unclaimedToken0 = unclaimedToken0.toString()
-        returnObj.unclaimedToken1 = unclaimedToken1.toString()
-        const clPositionPool = extendedPools.find((pl) => pl.id.toString() === clPosition.position.poolId.toString());
+        returnObj.unclaimedToken0 = (parseFloat(unclaimedToken0.toString()) / Math.pow(10, exponentToken0)).toString();
+        returnObj.unclaimedToken1 = (parseFloat(unclaimedToken1.toString()) / Math.pow(10, exponentToken1)).toString();
         returnObj.fee = clPositionPool?.fees7D.toString()
       }
       // not returning GAMM positons here; problematic for strat and apparently this is amm-liquidity route only

src/chains/osmosis/osmosis.utils.ts

@@ -1,4 +1,7 @@
+// Disable eslint for this file because it's a copy of the original file
+/* eslint-disable */
 import BigNumber from 'bignumber.js';
+import Decimal from 'decimal.js-light';
 
 export interface Fee {
   pool_id: string;
@@ -93,3 +96,102 @@
   return returnTick.toString()
 }
 
+
+export function calculatePriceToTick(desiredPriceString: string, exponentAtPriceOne: number, tickSpacing: number, is_lowerBound: boolean): string {
+  console.log(`Inputs: desiredPriceString=${desiredPriceString}, exponentAtPriceOne=${exponentAtPriceOne}, tickSpacing=${tickSpacing}, is_lowerBound=${is_lowerBound}`);
+
+  const desiredPrice = new BigNumber(desiredPriceString)
+  const exponent = new BigNumber(exponentAtPriceOne);
+  const geometricExponentIncrementDistanceInTicks = new BigNumber(9).multipliedBy(new BigNumber(10).exponentiatedBy(exponent.multipliedBy(-1)))
+
+  console.log(`Initial calculations: desiredPrice=${desiredPrice}, exponent=${exponent}, geometricExponentIncrementDistanceInTicks=${geometricExponentIncrementDistanceInTicks}`);
+
+  let currentPrice = new BigNumber(1);
+  let ticksPassed = new BigNumber(0);
+  let exponentAtCurrentTick = exponent;
+  let currentAdditiveIncrementInTicks = new BigNumber(10).exponentiatedBy(exponent)
+
+  if (desiredPrice.gt(new BigNumber(1))) {
+    while (currentPrice.lt(desiredPrice)) {
+      currentAdditiveIncrementInTicks = new BigNumber(10).exponentiatedBy(exponentAtCurrentTick);
+      const maxPriceForCurrentAdditiveIncrementInTicks = geometricExponentIncrementDistanceInTicks.multipliedBy(currentAdditiveIncrementInTicks);
+      currentPrice = currentPrice.plus(maxPriceForCurrentAdditiveIncrementInTicks);
+      exponentAtCurrentTick = exponentAtCurrentTick.plus(1);
+      ticksPassed = ticksPassed.plus(geometricExponentIncrementDistanceInTicks);
+
+      console.log(`Loop (desiredPrice > 1): currentPrice=${currentPrice}, exponentAtCurrentTick=${exponentAtCurrentTick}, ticksPassed=${ticksPassed}`);
+    }
+  } else {
+    exponentAtCurrentTick = exponent.minus(1);
+    while (currentPrice.gt(desiredPrice)) {
+      currentAdditiveIncrementInTicks = new BigNumber(10).exponentiatedBy(exponentAtCurrentTick);
+      const maxPriceForCurrentAdditiveIncrementInTicks = geometricExponentIncrementDistanceInTicks.multipliedBy(currentAdditiveIncrementInTicks);
+      currentPrice = currentPrice.minus(maxPriceForCurrentAdditiveIncrementInTicks);
+      exponentAtCurrentTick = exponentAtCurrentTick.minus(1);
+      ticksPassed = ticksPassed.minus(geometricExponentIncrementDistanceInTicks);
+
+      console.log(`Loop (desiredPrice <= 1): currentPrice=${currentPrice}, exponentAtCurrentTick=${exponentAtCurrentTick}, ticksPassed=${ticksPassed}`);
+    }
+  }
+
+  const ticksToBeFulfilledByExponentAtCurrentTick = desiredPrice.minus(currentPrice).dividedBy(currentAdditiveIncrementInTicks);
+  console.log(`Ticks to be fulfilled by current exponent: ${ticksToBeFulfilledByExponentAtCurrentTick}`);
+
+  const tickIndex = ticksPassed.plus(ticksToBeFulfilledByExponentAtCurrentTick);
+  console.log(`Tick index: ${tickIndex}`);
+
+  let returnTick = new BigNumber(0);
+  if (is_lowerBound){
+    returnTick = tickIndex.dividedBy(tickSpacing).integerValue(BigNumber.ROUND_DOWN).multipliedBy(tickSpacing)
+  }
+  else{
+    returnTick = tickIndex.dividedBy(tickSpacing).integerValue(BigNumber.ROUND_CEIL).multipliedBy(tickSpacing)
+  }
+
+  console.log(`Final calculations: tickIndex=${tickIndex}, returnTick=${BigInt(returnTick.toNumber()).toString()}`);
+  return BigInt(returnTick.toNumber()).toString();
+}
+
+function calculatePriceToTickDec(price: Decimal): [number, Error | null] {
+  if (price.isNegative()) {
+      return [0, new Error("price must be greater than zero")];
+  }
+
+  if (price.equals(1)) {
+      return [0, null];
+  }
+
+  // N.B. this exists to maintain backwards compatibility with
+  // the old version of the function that operated on decimal with precision of 18.
+  if (price.gte(types.MinSpotPriceBigDec)) {
+      price.tru(osmomath.DecPrecision);
+  }
+
+  // The approach here is to try determine which "geometric spacing" we are in.
+  let geoSpacing: TickExpIndexData;
+  let index: number;
+
+  if (price.gt(osmomath.BigOneDec)) {
+      index = 0;
+      geoSpacing = tickExpCache[index];
+      while (geoSpacing.maxPrice.lt(price)) {
+          index += 1;
+          geoSpacing = tickExpCache[index];
+      }
+  } else {
+      index = -1;
+      geoSpacing = tickExpCache[index];
+      while (geoSpacing.initialPrice.gt(price)) {
+          index -= 1;
+          geoSpacing = tickExpCache[index];
+      }
+  }
+
+  // Calculate the number of ticks that need to be filled by our current spacing
+  const priceInThisExponent = price.sub(geoSpacing.initialPrice);
+  const ticksFilledByCurrentSpacing = priceInThisExponent.div(geoSpacing.additiveIncrementPerTick).truncate();
+
+  // Calculate the final tick index
+  const tickIndex = ticksFilledByCurrentSpacing + geoSpacing.initialTick;
+  return [tickIndex, null];
+}