make getprice work just like our usual price calc incl decimals

Author: Luivatra

packages/cli/src/menus/pool.ts

@@ -23,7 +23,6 @@ import type { State } from "../types";
 import { getPoolData, prettyAssetId } from "../utils.js";
 import { ensureDeployment, getAssetAmount, printHeader } from "./shared.js";
 import { transactionDialog } from "./transaction.js";
-import { StableSwapsPool } from "@sundaeswap/math";
 
 export async function swapMenu(state: State): Promise<State> {
   await printHeader(state);
@@ -37,14 +36,7 @@ export async function swapMenu(state: State): Promise<State> {
     assetId: swapFrom.id,
   } as IPoolByAssetQuery)) as IPoolData[];
   let choices = pools!.map((pool) => {
-    const price =
-      pool.version === "Stableswaps"
-        ? StableSwapsPool.getPrice(
-            pool.liquidity.aReserve,
-            pool.liquidity.bReserve,
-            pool.linearAmplificationFactor!,
-          ).toNumber()
-        : Number(pool.liquidity.aReserve) / Number(pool.liquidity.bReserve);
+    const price = SundaeUtils.getPrice(pool);
     return {
       name: `${prettyAssetId(pool.assetA.assetId.toString())} / ${prettyAssetId(
         pool.assetB.assetId.toString(),

packages/core/src/Utilities/SundaeUtils.class.ts

@@ -583,19 +583,44 @@ export class SundaeUtils {
 
   /**
    * Calculates the price ratio between assets in a pool.
-   * For Stableswaps pools, uses the amplification factor for accurate pricing.
-   * For other pool types, returns the simple ratio of reserves.
+   * - Accounts for decimal differences between assets
+   * - For ADA pairs: returns ADA per token (assetA / assetB since ADA is always assetA)
+   * - For exotic pairs: returns inverted ratio (assetB / assetA)
+   * - For Stableswaps pools, uses the amplification factor for accurate pricing
    *
-   * @param {IPoolData} pool - The pool data containing reserves and version information.
-   * @returns {number} The price as a number representing the ratio of asset A to asset B.
+   * @param {IPoolData} pool - The pool data containing reserves, decimals, and version information.
+   * @returns {number} The price ratio adjusted for decimals.
    */
   static getPrice(pool: IPoolData): number {
-    return pool.version === "Stableswaps"
-      ? StableSwapsPool.getPrice(
-          pool.liquidity.aReserve,
-          pool.liquidity.bReserve,
-          pool.linearAmplificationFactor!,
-        ).toNumber()
-      : Number(pool.liquidity.aReserve) / Number(pool.liquidity.bReserve);
+    // Create AssetAmounts to handle decimal normalization
+    const assetAmountA = new AssetAmount<IAssetAmountMetadata>(
+      pool.liquidity.aReserve,
+      pool.assetA,
+    );
+    const assetAmountB = new AssetAmount<IAssetAmountMetadata>(
+      pool.liquidity.bReserve,
+      pool.assetB,
+    );
+
+    const isAdaPair = SundaeUtils.isAdaAsset(pool.assetA);
+
+    if (pool.version === EContractVersion.Stableswaps) {
+      // For stableswaps, both assets always have the same decimals
+      const price = StableSwapsPool.getPrice(
+        pool.liquidity.aReserve,
+        pool.liquidity.bReserve,
+        pool.linearAmplificationFactor!,
+      ).toNumber();
+
+      // For exotic pairs, invert the price
+      return isAdaPair ? price : 1 / price;
+    }
+
+    // For constant product pools, use the decimal-aware AssetAmount values
+    // ADA pairs: assetA (ADA) / assetB
+    // Exotic pairs: assetB / assetA (inverted)
+    return isAdaPair
+      ? assetAmountA.value.divide(assetAmountB.value).toNumber()
+      : assetAmountB.value.divide(assetAmountA.value).toNumber();
   }
 }

packages/core/src/Utilities/__tests__/SundaeUtils.class.test.ts

@@ -523,4 +523,135 @@ describe("SundaeUtils class", () => {
       );
     });
   });
+
+  describe("getPrice", () => {
+    it("should return price with decimal adjustment for ADA pairs (v1 pool)", () => {
+      // v1 pool: ADA (6 decimals) / TINDY (0 decimals)
+      // aReserve: 500000000n (500 ADA), bReserve: 250000000n (250M TINDY)
+      // Price should be: (500 ADA) / (250M TINDY) = 0.000002 ADA per TINDY
+      const price = SundaeUtils.getPrice(PREVIEW_DATA.pools.v1);
+      // Raw ratio without decimals would be: 500000000 / 250000000 = 2
+      // With decimal adjustment (ADA has 6 decimals, TINDY has 0):
+      // 2 * 10^(0-6) = 2 * 0.000001 = 0.000002
+      expect(price).toBeCloseTo(0.000002, 8);
+    });
+
+    it("should return price with decimal adjustment for ADA pairs (v3 pool)", () => {
+      // v3 pool: ADA (6 decimals) / TINDY (0 decimals)
+      // aReserve: 1018800000n (~1018.8 ADA), bReserve: 992067448n (~992M TINDY)
+      const price = SundaeUtils.getPrice(PREVIEW_DATA.pools.v3);
+      // Raw ratio: 1018800000 / 992067448 ≈ 1.0269
+      // With decimal adjustment: 1.0269 * 10^(0-6) ≈ 0.0000010269
+      expect(price).toBeCloseTo(0.0000010269, 8);
+    });
+
+    it("should handle exotic pairs (neither asset is ADA)", () => {
+      // Create a mock exotic pair pool
+      const exoticPool: IPoolData = {
+        ...PREVIEW_DATA.pools.v1,
+        assetA: {
+          assetId:
+            "99b071ce8580d6a3a11b4902145adb8bfd0d2a03935af8cf66403e15.55534443",
+          decimals: 6, // USDC
+        },
+        assetB: {
+          assetId:
+            "fa3eff2047fdf9293c5feef4dc85ce58097ea1c6da4845a351535183.74494e4459",
+          decimals: 0, // TINDY
+        },
+        liquidity: {
+          aReserve: 1000000000n, // 1000 USDC
+          bReserve: 500000000n, // 500M TINDY
+          lpTotal: 353553390n,
+        },
+      };
+
+      const price = SundaeUtils.getPrice(exoticPool);
+      // For exotic pairs, returns B/A (inverted) with decimal adjustment
+      // 500M TINDY / 1000 USDC = 500000 TINDY per USDC
+      expect(price).toBeCloseTo(500000, 0);
+    });
+
+    it("should handle same decimal assets", () => {
+      // Two assets with same decimals (e.g., two 6-decimal stablecoins)
+      const sameDecimalPool: IPoolData = {
+        ...PREVIEW_DATA.pools.v1,
+        assetA: {
+          assetId: "ada.lovelace",
+          decimals: 6,
+        },
+        assetB: {
+          assetId:
+            "99b071ce8580d6a3a11b4902145adb8bfd0d2a03935af8cf66403e15.55534443",
+          decimals: 6, // USDC
+        },
+        liquidity: {
+          aReserve: 1000000000n, // 1000 ADA
+          bReserve: 1000000000n, // 1000 USDC
+          lpTotal: 1000000000n,
+        },
+      };
+
+      const price = SundaeUtils.getPrice(sameDecimalPool);
+      // 1000 ADA / 1000 USDC = 1.0 ADA per USDC
+      expect(price).toBeCloseTo(1.0, 6);
+    });
+
+    it("should handle stableswap pools", () => {
+      // Create a stableswap pool mock
+      const stableswapPool: IPoolData = {
+        ...PREVIEW_DATA.pools.v1,
+        version: EContractVersion.Stableswaps,
+        assetA: {
+          assetId: "ada.lovelace",
+          decimals: 6,
+        },
+        assetB: {
+          assetId:
+            "99b071ce8580d6a3a11b4902145adb8bfd0d2a03935af8cf66403e15.55534443",
+          decimals: 6, // USDC
+        },
+        liquidity: {
+          aReserve: 20_000_000n, // 20 ADA
+          bReserve: 20_000_000n, // 20 USDC
+          lpTotal: 40_000_000n,
+        },
+        linearAmplificationFactor: 200n,
+      };
+
+      const price = SundaeUtils.getPrice(stableswapPool);
+      // For balanced stableswap pool, price should be close to 1.0
+      expect(price).toBeCloseTo(1.0, 4);
+    });
+
+    it("should handle unbalanced stableswap pools", () => {
+      // Stableswap with slightly unbalanced reserves (exotic pair)
+      const stableswapPool: IPoolData = {
+        ...PREVIEW_DATA.pools.v1,
+        version: EContractVersion.Stableswaps,
+        assetA: {
+          assetId:
+            "99b071ce8580d6a3a11b4902145adb8bfd0d2a03935af8cf66403e15.55534443",
+          decimals: 6, // USDC
+        },
+        assetB: {
+          assetId:
+            "99b071ce8580d6a3a11b4902145adb8bfd0d2a03935af8cf66403e15.55534454",
+          decimals: 6, // USDT
+        },
+        liquidity: {
+          aReserve: 1010000000n, // 1010 USDC
+          bReserve: 1000000000n, // 1000 USDT
+          lpTotal: 2000000000n,
+        },
+        linearAmplificationFactor: 200n,
+      };
+
+      const price = SundaeUtils.getPrice(stableswapPool);
+      // For exotic pair stableswap, price is inverted (1/rawPrice)
+      // Raw price is slightly > 1.0, so inverted is slightly < 1.0
+      expect(price).toBeGreaterThan(0.98);
+      expect(price).toBeLessThan(1.0);
+    });
+  });
 });