@paraswap/dex-lib 2.14.0 → 2.14.1

package/src/dex/woo-fi-v2/woo-fi-v2-integration.test.ts

@@ -0,0 +1,495 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface, Result } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { WooFiV2 } from './woo-fi-v2';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Address } from '@paraswap/core';
+import { ifaces } from './utils';
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  amounts: bigint[],
+  funcName: string,
+  srcTokenAddress: Address,
+  destTokenAddress: Address,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(funcName, [
+      srcTokenAddress,
+      destTokenAddress,
+      amount,
+    ]),
+  }));
+}
+
+function decodeReaderResult(
+  results: Result,
+  readerIface: Interface,
+  funcName: string,
+) {
+  return results.map(result => {
+    const parsed = readerIface.decodeFunctionResult(funcName, result);
+    return BigInt(parsed[0]._hex);
+  });
+}
+
+async function checkOnChainPricing(
+  wooFiV2: WooFiV2,
+  funcName: string,
+  blockNumber: number,
+  prices: bigint[],
+  amounts: bigint[],
+  srcTokenAddress: Address,
+  destTokenAddress: Address,
+) {
+  const exchangeAddress = wooFiV2.config.wooPPV2Address;
+
+  const readerIface = ifaces.PPV2;
+
+  const readerCallData = getReaderCalldata(
+    exchangeAddress,
+    readerIface,
+    amounts.slice(1),
+    funcName,
+    srcTokenAddress,
+    destTokenAddress,
+  );
+  const readerResult = (
+    await wooFiV2.dexHelper.multiContract.methods
+      .aggregate(readerCallData)
+      .call({}, blockNumber)
+  ).returnData;
+
+  const expectedPrices = [0n].concat(
+    decodeReaderResult(readerResult, readerIface, funcName),
+  );
+
+  expect(prices).toEqual(expectedPrices);
+}
+
+async function testPricingForPair(
+  wooFiV2: WooFiV2,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+  expectNoLiquidity: boolean = false,
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await wooFiV2.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  if (expectNoLiquidity) {
+    expect(pools.length).toEqual(0);
+    return;
+  }
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await wooFiV2.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (wooFiV2.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check if onchain pricing equals to calculated ones
+  await checkOnChainPricing(
+    wooFiV2,
+    funcNameToCheck,
+    blockNumber,
+    poolPrices![0].prices,
+    amounts,
+    networkTokens[srcTokenSymbol].address,
+    networkTokens[destTokenSymbol].address,
+  );
+}
+
+function runTestsForChain(
+  dexHelper: DummyDexHelper,
+  initProps: { dex: WooFiV2; blockNumber: number },
+  baseATokenSymbol: string,
+  quoteTokenSymbol: string,
+  baseBTokenSymbol: string,
+  untradableSymbol: string,
+  pricingCheckFuncName: string,
+  amountDecimalsDiff: number = 0,
+) {
+  const network = dexHelper.config.data.network;
+  const tokens = Tokens[network];
+
+  it(`getPoolIdentifiers and getPricesVolume SELL: ${baseATokenSymbol} -> ${quoteTokenSymbol}`, async function () {
+    const { dex: wooFiV2, blockNumber } = initProps;
+    const dexKey = wooFiV2.dexKey;
+    const srcTokenSymbol = baseATokenSymbol;
+    const destTokenSymbol = quoteTokenSymbol;
+
+    const amountsToTrade = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+    ];
+
+    await testPricingForPair(
+      wooFiV2,
+      network,
+      dexKey,
+      blockNumber,
+      srcTokenSymbol,
+      destTokenSymbol,
+      SwapSide.SELL,
+      amountsToTrade,
+      pricingCheckFuncName,
+    );
+  });
+
+  it(`getPoolIdentifiers and getPricesVolume SELL: ${quoteTokenSymbol} -> ${baseATokenSymbol}`, async function () {
+    const { dex: wooFiV2, blockNumber } = initProps;
+    const dexKey = wooFiV2.dexKey;
+    const srcTokenSymbol = quoteTokenSymbol;
+    const destTokenSymbol = baseATokenSymbol;
+
+    const amountsToTrade = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+    ];
+
+    await testPricingForPair(
+      wooFiV2,
+      network,
+      dexKey,
+      blockNumber,
+      srcTokenSymbol,
+      destTokenSymbol,
+      SwapSide.SELL,
+      amountsToTrade,
+      pricingCheckFuncName,
+    );
+  });
+
+  it(`getPoolIdentifiers and getPricesVolume SELL: ${baseATokenSymbol} -> ${baseBTokenSymbol}`, async function () {
+    const { dex: wooFiV2, blockNumber } = initProps;
+    const dexKey = wooFiV2.dexKey;
+    const srcTokenSymbol = baseATokenSymbol;
+    const destTokenSymbol = baseBTokenSymbol;
+
+    const amountsToTrade = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+    ];
+
+    await testPricingForPair(
+      wooFiV2,
+      network,
+      dexKey,
+      blockNumber,
+      srcTokenSymbol,
+      destTokenSymbol,
+      SwapSide.SELL,
+      amountsToTrade,
+      pricingCheckFuncName,
+    );
+  });
+
+  it('getPoolIdentifiers and getPricesVolume SELL: No Pool', async function () {
+    const { dex: wooFiV2, blockNumber } = initProps;
+    const dexKey = wooFiV2.dexKey;
+    const srcTokenSymbol = quoteTokenSymbol;
+    const destTokenSymbol = untradableSymbol;
+
+    const amountsToTrade = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals - amountDecimalsDiff],
+    ];
+    await testPricingForPair(
+      wooFiV2,
+      network,
+      dexKey,
+      blockNumber,
+      srcTokenSymbol,
+      destTokenSymbol,
+      SwapSide.SELL,
+      amountsToTrade,
+      pricingCheckFuncName,
+      true,
+    );
+  });
+
+  it('getTopPoolsForToken', async function () {
+    const { dex: wooFiV2 } = initProps;
+    const dexKey = wooFiV2.dexKey;
+    // We have to check without calling initializePricing, because
+    // pool-tracker is not calling that function
+    const newWooFiV2 = new WooFiV2(network, dexKey, dexHelper);
+    if (newWooFiV2.updatePoolState) {
+      await newWooFiV2.updatePoolState();
+    }
+    const poolLiquidity = await newWooFiV2.getTopPoolsForToken(
+      tokens[quoteTokenSymbol].address,
+      10,
+    );
+    console.log(`${quoteTokenSymbol} Top Pools:`, poolLiquidity);
+
+    if (!newWooFiV2.hasConstantPriceLargeAmounts) {
+      checkPoolsLiquidity(
+        poolLiquidity,
+        Tokens[network][quoteTokenSymbol].address,
+        dexKey,
+      );
+    }
+  });
+}
+
+describe('WooFiV2', function () {
+  const dexKey = 'WooFiV2';
+  const pricingCheckFuncName = 'tryQuery';
+
+  describe('Optimism', () => {
+    const network = Network.OPTIMISM;
+    const dexHelper = new DummyDexHelper(network);
+    const initProps: { dex: WooFiV2; blockNumber: number } = {
+      dex: new WooFiV2(network, dexKey, dexHelper),
+      blockNumber: 0,
+    };
+
+    beforeAll(async () => {
+      initProps.blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      await initProps.dex.initializePricing(initProps.blockNumber);
+    });
+
+    const baseATokenSymbol = 'WETH';
+    const quoteTokenSymbol = 'USDC';
+    const baseBTokenSymbol = 'WBTC';
+    const untradableSymbol = 'POPS';
+
+    runTestsForChain(
+      dexHelper,
+      initProps,
+      baseATokenSymbol,
+      quoteTokenSymbol,
+      baseBTokenSymbol,
+      untradableSymbol,
+      pricingCheckFuncName,
+    );
+  });
+
+  describe('BSC', () => {
+    const network = Network.BSC;
+    const dexHelper = new DummyDexHelper(network);
+    const initProps: { dex: WooFiV2; blockNumber: number } = {
+      dex: new WooFiV2(network, dexKey, dexHelper),
+      blockNumber: 0,
+    };
+
+    beforeAll(async () => {
+      initProps.blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      await initProps.dex.initializePricing(initProps.blockNumber);
+    });
+
+    const baseATokenSymbol = 'WBNB';
+    const quoteTokenSymbol = 'BUSD';
+    const baseBTokenSymbol = 'bBTC';
+    const untradableSymbol = 'POPS';
+
+    runTestsForChain(
+      dexHelper,
+      initProps,
+      baseATokenSymbol,
+      quoteTokenSymbol,
+      baseBTokenSymbol,
+      untradableSymbol,
+      pricingCheckFuncName,
+      2,
+    );
+  });
+
+  describe('Polygon', () => {
+    const network = Network.POLYGON;
+    const dexHelper = new DummyDexHelper(network);
+    const initProps: { dex: WooFiV2; blockNumber: number } = {
+      dex: new WooFiV2(network, dexKey, dexHelper),
+      blockNumber: 0,
+    };
+
+    beforeAll(async () => {
+      initProps.blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      await initProps.dex.initializePricing(initProps.blockNumber);
+    });
+
+    const baseATokenSymbol = 'WMATIC';
+    const quoteTokenSymbol = 'USDC';
+    const baseBTokenSymbol = 'WETH';
+    const untradableSymbol = 'POPS';
+
+    runTestsForChain(
+      dexHelper,
+      initProps,
+      baseATokenSymbol,
+      quoteTokenSymbol,
+      baseBTokenSymbol,
+      untradableSymbol,
+      pricingCheckFuncName,
+    );
+  });
+
+  describe('Fantom', () => {
+    const network = Network.FANTOM;
+    const dexHelper = new DummyDexHelper(network);
+    const initProps: { dex: WooFiV2; blockNumber: number } = {
+      dex: new WooFiV2(network, dexKey, dexHelper),
+      blockNumber: 0,
+    };
+
+    beforeAll(async () => {
+      initProps.blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      await initProps.dex.initializePricing(initProps.blockNumber);
+    });
+
+    const baseATokenSymbol = 'WFTM';
+    const quoteTokenSymbol = 'USDC';
+    const baseBTokenSymbol = 'ETH';
+    const untradableSymbol = 'POPS';
+
+    runTestsForChain(
+      dexHelper,
+      initProps,
+      baseATokenSymbol,
+      quoteTokenSymbol,
+      baseBTokenSymbol,
+      untradableSymbol,
+      pricingCheckFuncName,
+    );
+  });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const dexHelper = new DummyDexHelper(network);
+    const initProps: { dex: WooFiV2; blockNumber: number } = {
+      dex: new WooFiV2(network, dexKey, dexHelper),
+      blockNumber: 0,
+    };
+
+    beforeAll(async () => {
+      initProps.blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      await initProps.dex.initializePricing(initProps.blockNumber);
+    });
+
+    const baseATokenSymbol = 'WETH';
+    const quoteTokenSymbol = 'USDC';
+    const baseBTokenSymbol = 'WBTC';
+    const untradableSymbol = 'POPS';
+
+    runTestsForChain(
+      dexHelper,
+      initProps,
+      baseATokenSymbol,
+      quoteTokenSymbol,
+      baseBTokenSymbol,
+      untradableSymbol,
+      pricingCheckFuncName,
+    );
+  });
+
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+    const dexHelper = new DummyDexHelper(network);
+    const initProps: { dex: WooFiV2; blockNumber: number } = {
+      dex: new WooFiV2(network, dexKey, dexHelper),
+      blockNumber: 0,
+    };
+
+    beforeAll(async () => {
+      initProps.blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      await initProps.dex.initializePricing(initProps.blockNumber);
+    });
+
+    const baseATokenSymbol = 'WAVAX';
+    const quoteTokenSymbol = 'USDC';
+    const baseBTokenSymbol = 'BTCb';
+    const untradableSymbol = 'POPS';
+
+    runTestsForChain(
+      dexHelper,
+      initProps,
+      baseATokenSymbol,
+      quoteTokenSymbol,
+      baseBTokenSymbol,
+      untradableSymbol,
+      pricingCheckFuncName,
+      3,
+    );
+  });
+});

package/src/dex/woo-fi-v2/woo-fi-v2-math.ts

@@ -0,0 +1,195 @@
+import { PoolState, TokenState } from './types';
+import { Address, Logger } from '../../types';
+import { BI_POWS } from '../../bigint-constants';
+import { _require } from '../../utils';
+import { NULL_STATE } from './constants';
+
+function handleMathError(e: unknown, logger: Logger) {
+  if (e instanceof Error && e.message.startsWith('WooGuardian:')) {
+    logger.warn('WooFi Guardian check Error:', e);
+    return;
+  }
+  logger.error('Unexpected error in WooFi math:', e);
+}
+
+function max(a: bigint, b: bigint): bigint {
+  return a > b ? a : b;
+}
+
+export class WooFiV2Math {
+  state: PoolState = NULL_STATE;
+
+  constructor(
+    private readonly logger: Logger,
+    private readonly _quoteToken: Address,
+  ) {}
+
+  query(
+    fromToken: Address,
+    toToken: Address,
+    fromAmounts: bigint[],
+  ): bigint[] | null {
+    try {
+      if (fromToken === this._quoteToken) {
+        return this._querySellQuote(toToken, fromAmounts);
+      } else if (toToken === this._quoteToken) {
+        return this._querySellBase(fromToken, fromAmounts);
+      } else {
+        return this._queryBaseToBase(fromToken, toToken, fromAmounts);
+      }
+    } catch (e) {
+      handleMathError(e, this.logger);
+      return null;
+    }
+  }
+
+  _querySellBase(baseToken: Address, baseAmounts: bigint[]): bigint[] | null {
+    try {
+      const _state = this.state.tokenStates[baseToken];
+      let quoteAmounts = this._calcQuoteAmountSellBase(
+        baseToken,
+        baseAmounts,
+        _state,
+      );
+
+      quoteAmounts = quoteAmounts.map(amount => {
+        return amount <= this.state.tokenInfos[this._quoteToken].reserve
+          ? amount
+          : 0n;
+      });
+
+      const feeRate = this.state.tokenInfos[baseToken].feeRate;
+      return this._takeFee(quoteAmounts, feeRate);
+    } catch (e) {
+      handleMathError(e, this.logger);
+      return null;
+    }
+  }
+
+  _querySellQuote(baseToken: Address, quoteAmounts: bigint[]): bigint[] | null {
+    try {
+      const feeRate = this.state.tokenInfos[baseToken].feeRate;
+      quoteAmounts = this._takeFee(quoteAmounts, feeRate);
+
+      const _state = this.state.tokenStates[baseToken];
+      let toAmounts = this._calcBaseAmountSellQuote(
+        baseToken,
+        quoteAmounts,
+        _state,
+      );
+
+      const baseReserve = this.state.tokenInfos[baseToken].reserve;
+      return toAmounts.map(amount => {
+        return amount <= baseReserve ? amount : 0n;
+      });
+    } catch (e) {
+      handleMathError(e, this.logger);
+      return null;
+    }
+  }
+
+  _queryBaseToBase(
+    baseToken1: Address,
+    baseToken2: Address,
+    base1Amounts: bigint[],
+  ): bigint[] | null {
+    try {
+      let state1: TokenState = this.state.tokenStates[baseToken1];
+      let state2: TokenState = this.state.tokenStates[baseToken2];
+
+      const feeRate1 = this.state.tokenInfos[baseToken1].feeRate;
+      const feeRate2 = this.state.tokenInfos[baseToken2].feeRate;
+
+      const spread = max(state1.spread, state2.spread) / 2n;
+      const feeRate = max(feeRate1, feeRate2);
+
+      state1.spread = spread;
+      state2.spread = spread;
+
+      let quoteAmounts = this._calcQuoteAmountSellBase(
+        baseToken1,
+        base1Amounts,
+        state1,
+      );
+      quoteAmounts = this._takeFeeAndCheckReserve(quoteAmounts, feeRate);
+
+      let toAmounts = this._calcBaseAmountSellQuote(
+        baseToken2,
+        quoteAmounts,
+        state2,
+      );
+
+      return toAmounts.map(toAmount => {
+        return toAmount <= this.state.tokenInfos[baseToken2].reserve
+          ? toAmount
+          : 0n;
+      });
+    } catch (e) {
+      handleMathError(e, this.logger);
+      return null;
+    }
+  }
+
+  protected _takeFeeAndCheckReserve(
+    amounts: bigint[],
+    feeRate: bigint,
+  ): bigint[] {
+    return amounts.map(amount => {
+      if (amount === 0n) return 0n;
+      const lpFee = (amount * feeRate) / BI_POWS[5];
+      const reserve = this.state.tokenInfos[this._quoteToken].reserve;
+      return lpFee > reserve ? 0n : amount - lpFee;
+    });
+  }
+
+  protected _takeFee(amounts: bigint[], feeRate: bigint): bigint[] {
+    return amounts.map(amount => {
+      const lpFee = (amount * feeRate) / BI_POWS[5];
+      return amount === 0n ? 0n : amount - lpFee;
+    });
+  }
+
+  protected _calcQuoteAmountSellBase(
+    baseToken: Address,
+    baseAmounts: bigint[],
+    state: TokenState,
+  ): bigint[] {
+    let { priceDec, quoteDec, baseDec } = this.state.decimals[baseToken];
+
+    return baseAmounts.map(baseAmount => {
+      if (baseAmount === 0n) return 0n;
+
+      const coef: bigint =
+        BI_POWS[18] -
+        (state.coeff * baseAmount * state.price) / baseDec / priceDec -
+        state.spread;
+
+      return (
+        (((baseAmount * quoteDec * state.price) / priceDec) * coef) /
+        BI_POWS[18] /
+        baseDec
+      );
+    });
+  }
+
+  protected _calcBaseAmountSellQuote(
+    baseToken: string,
+    quoteAmounts: bigint[],
+    state: TokenState,
+  ): bigint[] {
+    let { priceDec, quoteDec, baseDec } = this.state.decimals[baseToken];
+
+    return quoteAmounts.map(quoteAmount => {
+      if (quoteAmount === 0n) return 0n;
+
+      const coef: bigint =
+        BI_POWS[18] - (quoteAmount * state.coeff) / quoteDec - state.spread;
+
+      return (
+        (((quoteAmount * baseDec * priceDec) / state.price) * coef) /
+        BI_POWS[18] /
+        quoteDec
+      );
+    });
+  }
+}