Merge pull request #257 from bancorprotocol/fix-calculateLConstant

Fix function `calculateLConstant`

Author: zavelevsky

src/adapters/uni-v3/adapter.ts

@@ -1,4 +1,4 @@
-import { Decimal, MAX_UINT256 } from '../../utils/numerics';
+import { BigNumber, Decimal, ONE } from '../../utils/numerics';
 import { EncodedOrder, EncodedStrategy } from '../../common/types';
 import { UniV3CastStrategy, UniV3Pool, UniV3Position } from './types';
 import { decodeFloat, decodeOrder } from '../../utils/encoders';
@@ -28,65 +28,53 @@ function calculateImpliedTick(rate: Decimal, roundUp: boolean): number {
  */
 function calculateLConstant(order: EncodedOrder): string {
   if (order.A.isZero()) {
-    return MAX_UINT256.toString();
+    return Infinity.toString();
   }
-  return order.z.div(decodeFloat(order.A)).toString();
+  return order.z.mul(ONE).div(decodeFloat(order.A)).toString();
 }
 
-function calculateSqrtPriceX96(order: EncodedOrder): string {
-  const decodedOrder = decodeOrder(order);
-  const marginalRate = new Decimal(decodedOrder.marginalRate);
-  const sqrtRate = marginalRate.sqrt();
+function calculateSqrtPriceX96(marginal: Decimal, roundUp: boolean): string {
+  const sqrtRate = marginal.sqrt();
   const sqrtPriceX96 = sqrtRate.mul(new Decimal(2).pow(96));
-  return sqrtPriceX96.floor().toString();
+  return roundUp
+    ? sqrtPriceX96.ceil().toString()
+    : sqrtPriceX96.floor().toString();
 }
 
 /**
  * Calculates position information for a Carbon order
  * @param {EncodedOrder} order - The Carbon order
- * @param {boolean} isSellOrder - Whether this is a sell order
+ * @param {boolean} invertRates - Whether to invert the rates
  * @returns {UniV3Position} The calculated Uniswap V3 position
  */
 function calculatePositionInformation(
   order: EncodedOrder,
-  isSellOrder: boolean
+  invertRates: boolean
 ): UniV3Position {
   const decodedOrder = decodeOrder(order);
   const priceLow = new Decimal(decodedOrder.lowestRate);
   const priceHigh = new Decimal(decodedOrder.highestRate);
+  const priceMarginal = new Decimal(decodedOrder.marginalRate);
 
-  if (isSellOrder) {
+  if (!invertRates) {
     return {
       tickUpper: calculateImpliedTick(priceHigh, true),
       tickLower: calculateImpliedTick(priceLow, false),
       liquidity: calculateLConstant(order),
-      sqrtPriceX96: calculateSqrtPriceX96(order),
+      sqrtPriceX96: calculateSqrtPriceX96(priceMarginal, false),
     };
   }
 
   // For buy orders, invert the prices
-  const invertedPriceLow = new Decimal(1).div(priceHigh);
-  const invertedPriceHigh = new Decimal(1).div(priceLow);
+  const invertedPriceHigh = new Decimal(1).div(priceHigh);
+  const invertedPriceLow = new Decimal(1).div(priceLow);
+  const invertedPriceMarginal = new Decimal(1).div(priceMarginal);
 
   return {
-    tickUpper: calculateImpliedTick(invertedPriceHigh, true),
-    tickLower: calculateImpliedTick(invertedPriceLow, false),
+    tickUpper: calculateImpliedTick(invertedPriceLow, true),
+    tickLower: calculateImpliedTick(invertedPriceHigh, false),
     liquidity: calculateLConstant(order),
-    sqrtPriceX96: calculateSqrtPriceX96(order),
-  };
-}
-
-/**
- * Defines the pool configuration for a token pair
- * @param {string} baseToken - The base token address
- * @param {string} quoteToken - The quote token address
- * @returns {UniV3Pool} The pool configuration
- */
-function definePool(baseToken: string, quoteToken: string): UniV3Pool {
-  return {
-    xAxisToken: quoteToken,
-    yAxisToken: baseToken,
-    tickSpacing: DEFAULT_TICK_SPACING,
+    sqrtPriceX96: calculateSqrtPriceX96(invertedPriceMarginal, true),
   };
 }
 
@@ -96,12 +84,23 @@ function definePool(baseToken: string, quoteToken: string): UniV3Pool {
  * @returns {UniV3CastStrategy} The strategy in Uniswap V3 format
  */
 export function castToUniV3(strategy: EncodedStrategy): UniV3CastStrategy {
-  const pool = definePool(strategy.token0, strategy.token1);
+  // use the token addresses to define which is the base token and which is the quote token. Base token is the token with the lowest address.
+
+  const addr0 = BigNumber.from(strategy.token0);
+  const addr1 = BigNumber.from(strategy.token1);
+
+  const isToken0XAxis = addr0.lt(addr1);
+
+  const pool: UniV3Pool = {
+    xAxisToken: isToken0XAxis ? strategy.token0 : strategy.token1,
+    yAxisToken: isToken0XAxis ? strategy.token1 : strategy.token0,
+    tickSpacing: DEFAULT_TICK_SPACING,
+  };
 
   return {
     pool,
-    sellOrder: calculatePositionInformation(strategy.order0, true),
-    buyOrder: calculatePositionInformation(strategy.order1, false),
+    sellOrder: calculatePositionInformation(strategy.order0, isToken0XAxis),
+    buyOrder: calculatePositionInformation(strategy.order1, !isToken0XAxis),
   };
 }