@alcorexchange/alcor-swap-sdk 1.0.0

package/test/position.test.ts

@@ -0,0 +1,579 @@
+import { Token } from "entities/token";
+import { Percent } from "entities/fractions/percent";
+import JSBI from "jsbi";
+import { FeeAmount, TICK_SPACINGS } from "internalConstants";
+import { encodeSqrtRatioX64 } from "utils/encodeSqrtRatioX64";
+import { nearestUsableTick } from "utils/nearestUsableTick";
+import { TickMath } from "utils/tickMath";
+import { Pool } from "entities/pool";
+import { Position } from "entities/position";
+
+describe.skip("Position", () => {
+  const USDC = new Token("contracta", 6, "USDC", "USD Coin");
+  const DAI = new Token("contractb", 18, "DAI", "DAI Stablecoin");
+  const POOL_SQRT_RATIO_START = encodeSqrtRatioX64(100e6, 100e18);
+  const POOL_TICK_CURRENT = TickMath.getTickAtSqrtRatio(POOL_SQRT_RATIO_START);
+  const TICK_SPACING = TICK_SPACINGS[FeeAmount.LOW];
+  const DAI_USDC_POOL = new Pool({
+    tokenA: DAI,
+    tokenB: USDC,
+    fee: FeeAmount.LOW,
+    sqrtPriceX64: POOL_SQRT_RATIO_START,
+    liquidity: 0,
+    tickCurrent: POOL_TICK_CURRENT,
+    ticks: []
+  });
+
+  it("can be constructed around 0 tick", () => {
+    const position = new Position({
+      pool: DAI_USDC_POOL,
+      liquidity: 1,
+      tickLower: -10,
+      tickUpper: 10,
+    });
+    expect(position.liquidity).toEqual(JSBI.BigInt(1));
+  });
+
+  it("can use min and max ticks", () => {
+    const position = new Position({
+      pool: DAI_USDC_POOL,
+      liquidity: 1,
+      tickLower: nearestUsableTick(TickMath.MIN_TICK, TICK_SPACING),
+      tickUpper: nearestUsableTick(TickMath.MAX_TICK, TICK_SPACING),
+    });
+    expect(position.liquidity).toEqual(JSBI.BigInt(1));
+  });
+
+  it("tick lower must be less than tick upper", () => {
+    expect(
+      () =>
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 1,
+          tickLower: 10,
+          tickUpper: -10,
+        })
+    ).toThrow("TICK_ORDER");
+  });
+
+  it("tick lower cannot equal tick upper", () => {
+    expect(
+      () =>
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 1,
+          tickLower: -10,
+          tickUpper: -10,
+        })
+    ).toThrow("TICK_ORDER");
+  });
+
+  it("tick lower must be multiple of tick spacing", () => {
+    expect(
+      () =>
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 1,
+          tickLower: -5,
+          tickUpper: 10,
+        })
+    ).toThrow("TICK_LOWER");
+  });
+
+  it("tick lower must be greater than MIN_TICK", () => {
+    expect(
+      () =>
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 1,
+          tickLower:
+            nearestUsableTick(TickMath.MIN_TICK, TICK_SPACING) - TICK_SPACING,
+          tickUpper: 10,
+        })
+    ).toThrow("TICK_LOWER");
+  });
+
+  it("tick upper must be multiple of tick spacing", () => {
+    expect(
+      () =>
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 1,
+          tickLower: -10,
+          tickUpper: 15,
+        })
+    ).toThrow("TICK_UPPER");
+  });
+
+  it("tick upper must be less than MAX_TICK", () => {
+    expect(
+      () =>
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 1,
+          tickLower: -10,
+          tickUpper:
+            nearestUsableTick(TickMath.MAX_TICK, TICK_SPACING) + TICK_SPACING,
+        })
+    ).toThrow("TICK_UPPER");
+  });
+
+  describe("#amountA", () => {
+    it("is correct for price above", () => {
+      expect(
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e12,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        }).amountA.quotient.toString()
+      ).toEqual("49949961958869841");
+    });
+    it("is correct for price below", () => {
+      expect(
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING,
+        }).amountA.quotient.toString()
+      ).toEqual("0");
+    });
+    it("is correct for in-range position", () => {
+      expect(
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        }).amountA.quotient.toString()
+      ).toEqual("120054069145287995769396");
+    });
+  });
+
+  describe("#amountB", () => {
+    it("is correct for price above", () => {
+      expect(
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        }).amountB.quotient.toString()
+      ).toEqual("0");
+    });
+    it("is correct for price below", () => {
+      expect(
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING,
+        }).amountB.quotient.toString()
+      ).toEqual("49970077052");
+    });
+    it("is correct for in-range position", () => {
+      expect(
+        new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        }).amountB.quotient.toString()
+      ).toEqual("79831926242");
+    });
+  });
+
+  describe("#mintAmountsWithSlippage", () => {
+    describe("0 slippage", () => {
+      const slippageTolerance = new Percent(0);
+
+      it("is correct for positions below", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("49949961958869841738198");
+        expect(amountB.toString()).toEqual("0");
+      });
+
+      it("is correct for positions above", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("0");
+        expect(amountB.toString()).toEqual("49970077053");
+      });
+
+      it("is correct for positions within", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("120054069145287995740584");
+        expect(amountB.toString()).toEqual("79831926243");
+      });
+    });
+
+    describe(".05% slippage", () => {
+      const slippageTolerance = new Percent(5, 10000);
+
+      it("is correct for positions below", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("49949961958869841738198");
+        expect(amountB.toString()).toEqual("0");
+      });
+
+      it("is correct for positions above", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("0");
+        expect(amountB.toString()).toEqual("49970077053");
+      });
+
+      it("is correct for positions within", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("95063440240746211432007");
+        expect(amountB.toString()).toEqual("54828800461");
+      });
+    });
+
+    describe("5% slippage tolerance", () => {
+      const slippageTolerance = new Percent(5, 100);
+
+      it("is correct for pool at min price", () => {
+        const position = new Position({
+          pool: new Pool({
+            tokenA: DAI,
+            tokenB: USDC,
+            fee: FeeAmount.LOW,
+            sqrtPriceX64: TickMath.MIN_SQRT_RATIO,
+            liquidity: 0,
+            tickCurrent: TickMath.MIN_TICK,
+            ticks: []
+          }),
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("49949961958869841754181");
+        expect(amountB.toString()).toEqual("0");
+      });
+
+      it("is correct for pool at max price", () => {
+        const position = new Position({
+          pool: new Pool({
+            tokenA: DAI,
+            tokenB: USDC,
+            fee: FeeAmount.LOW,
+            sqrtPriceX64: JSBI.subtract(TickMath.MAX_SQRT_RATIO, JSBI.BigInt(1)),
+            liquidity: 0,
+            tickCurrent: TickMath.MAX_TICK - 1,
+            ticks: []
+          }),
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("0");
+        expect(amountB.toString()).toEqual("50045084659");
+      });
+    });
+  });
+
+  describe("#burnAmountsWithSlippage", () => {
+    describe("0 slippage", () => {
+      const slippageTolerance = new Percent(0);
+
+      it("is correct for positions below", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("49949961958869841754181");
+        expect(amountB.toString()).toEqual("0");
+      });
+
+      it("is correct for positions above", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING,
+        });
+
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("0");
+        expect(amountB.toString()).toEqual("49970077052");
+      });
+
+      it("is correct for positions within", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("120054069145287995769396");
+        expect(amountB.toString()).toEqual("79831926242");
+      });
+    });
+
+    describe(".05% slippage", () => {
+      const slippageTolerance = new Percent(5, 10000);
+
+      it("is correct for positions below", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("49949961958869841754181");
+        expect(amountB.toString()).toEqual("0");
+      });
+
+      it("is correct for positions above", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING,
+        });
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("0");
+        expect(amountB.toString()).toEqual("49970077052");
+      });
+
+      it("is correct for positions within", () => {
+        const position = new Position({
+          pool: DAI_USDC_POOL,
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) -
+            TICK_SPACING * 2,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+        const { amountA, amountB } =
+          position.burnAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("95063440240746211454822");
+        expect(amountB.toString()).toEqual("54828800460");
+      });
+    });
+
+    describe("5% slippage tolerance", () => {
+      const slippageTolerance = new Percent(5, 100);
+
+      it("is correct for pool at min price", () => {
+        const position = new Position({
+          pool: new Pool({
+            tokenA: DAI,
+            tokenB: USDC,
+            fee: FeeAmount.LOW,
+            sqrtPriceX64: TickMath.MIN_SQRT_RATIO,
+            liquidity: 0,
+            tickCurrent: TickMath.MIN_TICK,
+            ticks: []
+          }),
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("49949961958869841738198");
+        expect(amountB.toString()).toEqual("0");
+      });
+
+      it("is correct for pool at max price", () => {
+        const position = new Position({
+          pool: new Pool({
+            tokenA: DAI,
+            tokenB: USDC,
+            fee: FeeAmount.LOW,
+            sqrtPriceX64: JSBI.subtract(TickMath.MAX_SQRT_RATIO, JSBI.BigInt(1)),
+            liquidity: 0,
+            tickCurrent: TickMath.MAX_TICK - 1,
+            ticks: []
+          }),
+          liquidity: 100e18,
+          tickLower:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+          tickUpper:
+            nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) +
+            TICK_SPACING * 2,
+        });
+
+        const { amountA, amountB } =
+          position.mintAmountsWithSlippage(slippageTolerance);
+        expect(amountA.toString()).toEqual("0");
+        expect(amountB.toString()).toEqual("50045084660");
+      });
+    });
+  });
+
+  describe("#mintAmounts", () => {
+    it("is correct for price above", () => {
+      const { amountA, amountB } = new Position({
+        pool: DAI_USDC_POOL,
+        liquidity: 100e18,
+        tickLower:
+          nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING,
+        tickUpper:
+          nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING * 2,
+      }).mintAmounts;
+      expect(amountA.toString()).toEqual("49949961958869841754182");
+      expect(amountB.toString()).toEqual("0");
+    });
+    it("is correct for price below", () => {
+      const { amountA, amountB } = new Position({
+        pool: DAI_USDC_POOL,
+        liquidity: 100e18,
+        tickLower:
+          nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING * 2,
+        tickUpper:
+          nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING,
+      }).mintAmounts;
+      expect(amountA.toString()).toEqual("0");
+      expect(amountB.toString()).toEqual("49970077053");
+    });
+    it("is correct for in-range position", () => {
+      const { amountA, amountB } = new Position({
+        pool: DAI_USDC_POOL,
+        liquidity: 100e18,
+        tickLower:
+          nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) - TICK_SPACING * 2,
+        tickUpper:
+          nearestUsableTick(POOL_TICK_CURRENT, TICK_SPACING) + TICK_SPACING * 2,
+      }).mintAmounts;
+      // note these are rounded up
+      expect(amountA.toString()).toEqual("120054069145287995769397");
+      expect(amountB.toString()).toEqual("79831926243");
+    });
+  });
+});

package/test/positionLibrary.test.ts

@@ -0,0 +1,31 @@
+import JSBI from "jsbi";
+import { PositionLibrary } from "utils/positionLibrary";
+import { ZERO } from "internalConstants";
+
+describe("PositionLibrary", () => {
+  describe("#getTokensOwed", () => {
+    it("0", () => {
+      const [tokensOwed0, tokensOwed1] = PositionLibrary.getTokensOwed(
+        ZERO,
+        ZERO,
+        ZERO,
+        ZERO,
+        ZERO
+      );
+      expect(tokensOwed0).toEqual(ZERO);
+      expect(tokensOwed1).toEqual(ZERO);
+    });
+
+    it("non-0", () => {
+      const [tokensOwed0, tokensOwed1] = PositionLibrary.getTokensOwed(
+        ZERO,
+        ZERO,
+        JSBI.BigInt(1),
+        JSBI.exponentiate(JSBI.BigInt(2), JSBI.BigInt(64)),
+        JSBI.exponentiate(JSBI.BigInt(2), JSBI.BigInt(64))
+      );
+      expect(tokensOwed0).toEqual(JSBI.BigInt(1));
+      expect(tokensOwed1).toEqual(JSBI.BigInt(1));
+    });
+  });
+});

package/test/price.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const token_1 = require("entities/token");
+const currencyAmount_1 = require("../src/entities/fractions/currencyAmount");
+const price_1 = require("../src/entities/fractions/price");
+describe("Price", () => {
+    const CONTRACT_ZERO = "contracta";
+    const CONTRACT_ONE = "contractb";
+    const t0 = new token_1.Token(CONTRACT_ZERO, 8, "ABC");
+    const t0_6 = new token_1.Token(CONTRACT_ZERO, 6, "BCD");
+    const t1 = new token_1.Token(CONTRACT_ONE, 8, "EFG");
+    describe("#constructor", () => {
+        it("array format works", () => {
+            const price = new price_1.Price(t0, t1, 1, 54321);
+            expect(price.toSignificant(5)).toEqual("54321");
+            expect(price.baseCurrency.equals(t0));
+            expect(price.quoteCurrency.equals(t1));
+        });
+        it("object format works", () => {
+            const price = new price_1.Price({
+                baseAmount: currencyAmount_1.CurrencyAmount.fromRawAmount(t0, 1),
+                quoteAmount: currencyAmount_1.CurrencyAmount.fromRawAmount(t1, 54321),
+            });
+            expect(price.toSignificant(5)).toEqual("54321");
+            expect(price.baseCurrency.equals(t0));
+            expect(price.quoteCurrency.equals(t1));
+        });
+    });
+    describe("#quote", () => {
+        it("returns correct value", () => {
+            const price = new price_1.Price(t0, t1, 1, 5);
+            expect(price.quote(currencyAmount_1.CurrencyAmount.fromRawAmount(t0, 10))).toEqual(currencyAmount_1.CurrencyAmount.fromRawAmount(t1, 50));
+        });
+    });
+    describe("#toSignificant", () => {
+        it("no decimals", () => {
+            const p = new price_1.Price(t0, t1, 123, 456);
+            expect(p.toSignificant(4)).toEqual("3.707");
+        });
+        it("no decimals flip ratio", () => {
+            const p = new price_1.Price(t0, t1, 456, 123);
+            expect(p.toSignificant(4)).toEqual("0.2697");
+        });
+        it("with decimal difference", () => {
+            const p = new price_1.Price(t0_6, t1, 123, 456);
+            expect(p.toSignificant(4)).toEqual("0.03707");
+        });
+        it("with decimal difference flipped", () => {
+            const p = new price_1.Price(t0_6, t1, 456, 123);
+            expect(p.toSignificant(4)).toEqual("0.002697");
+        });
+        it("with decimal difference flipped base quote flipped", () => {
+            const p = new price_1.Price(t1, t0_6, 456, 123);
+            expect(p.toSignificant(4)).toEqual("26.97");
+        });
+    });
+});