@paraswap/dex-lib 2.42.24 → 2.42.25-wombat.0

package/src/dex/wombat/wombat-integration.test.ts

@@ -0,0 +1,258 @@
+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 { Wombat } from './wombat';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Token } from '../../types';
+import { Address } from '@paraswap/core';
+import { WombatConfig } from './config';
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  side: SwapSide,
+  fromToken: Token,
+  toToken: Token,
+  amounts: bigint[],
+  funcName: string,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(
+      funcName,
+      side == SwapSide.SELL
+        ? [fromToken.address, toToken.address, amount]
+        : [toToken.address, fromToken.address, -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(
+  wombat: Wombat,
+  pool: Address,
+  fromToken: Token,
+  toToken: Token,
+  side: SwapSide,
+  funcName: string,
+  blockNumber: number,
+  prices: bigint[],
+  amounts: bigint[],
+) {
+  const exchangeAddress = pool; // TODO: Put here the real exchange address
+
+  const readerIface = Wombat.poolInterface;
+
+  const readerCallData = getReaderCalldata(
+    exchangeAddress,
+    readerIface,
+    side,
+    fromToken,
+    toToken,
+    amounts.slice(1),
+    funcName,
+  );
+  const readerResult = (
+    await wombat.dexHelper.multiContract.methods
+      .aggregate(readerCallData)
+      .call({}, blockNumber)
+  ).returnData;
+
+  const expectedPrices = [0n].concat(
+    decodeReaderResult(readerResult, readerIface, funcName),
+  );
+
+  expect(prices).toEqual(expectedPrices);
+}
+
+async function testPricingOnNetwork(
+  wombat: Wombat,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await wombat.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await wombat.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (wombat.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check if onchain pricing equals to calculated ones
+  await checkOnChainPricing(
+    wombat,
+    poolPrices![0].data.exchange,
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    funcNameToCheck,
+    blockNumber,
+    poolPrices![0].prices,
+    amounts,
+  );
+}
+
+describe('Wombat', function () {
+  const dexKey = 'Wombat';
+  let blockNumber: number;
+  let wombat: Wombat;
+
+  Object.keys(WombatConfig[dexKey]).forEach(key => {
+    describe(`network ${key}`, () => {
+      const network = Number(key) as Network;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      const srcTokenSymbol = 'USDC';
+      const destTokenSymbol = network == Network.BASE ? 'USDbC' : 'USDT';
+
+      let amountsForSell = [
+        0n,
+        1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      ];
+
+      let amountsForBuy = [
+        0n,
+        1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        2n * BI_POWS[tokens[destTokenSymbol].decimals],
+        3n * BI_POWS[tokens[destTokenSymbol].decimals],
+        4n * BI_POWS[tokens[destTokenSymbol].decimals],
+        5n * BI_POWS[tokens[destTokenSymbol].decimals],
+        6n * BI_POWS[tokens[destTokenSymbol].decimals],
+        7n * BI_POWS[tokens[destTokenSymbol].decimals],
+        8n * BI_POWS[tokens[destTokenSymbol].decimals],
+        9n * BI_POWS[tokens[destTokenSymbol].decimals],
+        10n * BI_POWS[tokens[destTokenSymbol].decimals],
+      ];
+
+      // OPTIMISM has very low liquidity currently, so we have to use very small amounts
+      // if (network === Network.OPTIMISM) {
+      //   amountsForSell = amountsForSell.map(a => a / 100n);
+      //   amountsForBuy = amountsForBuy.map(a => a / 100n);
+      // }
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        wombat = new Wombat(network, dexKey, dexHelper);
+      });
+
+      it('getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        if (wombat.updatePoolState) {
+          await wombat.updatePoolState();
+        }
+        const poolLiquidity = await wombat.getTopPoolsForToken(
+          tokens[srcTokenSymbol].address,
+          10,
+        );
+        console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+        if (!wombat.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][srcTokenSymbol].address,
+            dexKey,
+          );
+        }
+      });
+
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        if (wombat.initializePricing) {
+          await wombat.initializePricing(blockNumber);
+        }
+        await testPricingOnNetwork(
+          wombat,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.SELL,
+          amountsForSell,
+          'quotePotentialSwap',
+        );
+      });
+
+      it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+        if (wombat.initializePricing) {
+          await wombat.initializePricing(blockNumber);
+        }
+        await testPricingOnNetwork(
+          wombat,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.BUY,
+          amountsForBuy,
+          'quotePotentialSwap',
+        );
+      });
+    });
+  });
+});

package/src/dex/wombat/wombat-pool.ts

@@ -0,0 +1,231 @@
+import { Interface } from '@ethersproject/abi';
+import { Address } from '@paraswap/core';
+import _ from 'lodash';
+
+import { MultiCallParams, MultiResult } from '../../lib/multi-wrapper';
+import { IDexHelper } from '../../dex-helper';
+import { StatefulRpcPoller } from '../../lib/stateful-rpc-poller/stateful-rpc-poller';
+import { StatePollingManager } from '../../lib/stateful-rpc-poller/state-polling-manager';
+import { ObjWithUpdateInfo } from '../../lib/stateful-rpc-poller/types';
+import { pollingManagerCbExtractor } from '../../lib/stateful-rpc-poller/utils';
+import {
+  addressArrayDecode,
+  booleanDecode,
+  uint256ToBigInt,
+  uint8ToNumber,
+} from '../../lib/decoders';
+import PoolABI from '../../abi/wombat/pool.json';
+import AssetABI from '../../abi/wombat/asset.json';
+import { uint120ToBigInt } from './utils';
+import { AssetState, MulticallResultOutputs, PoolState } from './types';
+
+export class WombatPool extends StatefulRpcPoller<
+  PoolState,
+  MulticallResultOutputs
+> {
+  static readonly poolInterface = new Interface(PoolABI);
+  static readonly assetInterface = new Interface(AssetABI);
+
+  constructor(
+    dexKey: string,
+    poolIdentifier: string,
+    dexHelper: IDexHelper,
+    protected poolAddress: Address,
+    protected asset2TokenMap: Map<Address, Address>,
+  ) {
+    const callbacks = pollingManagerCbExtractor(
+      StatePollingManager.getInstance(dexHelper),
+    );
+
+    super(dexKey, poolIdentifier, dexHelper, 0, 0, false, callbacks);
+  }
+
+  protected _getFetchStateMultiCalls(): MultiCallParams<MulticallResultOutputs>[] {
+    const params: MultiCallParams<MulticallResultOutputs>[] = [];
+
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('paused'),
+      decodeFunction: booleanDecode,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('ampFactor'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('haircutRate'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('startCovRatio'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('endCovRatio'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('getTokens'),
+      decodeFunction: addressArrayDecode,
+    });
+
+    this.asset2TokenMap.forEach((token, asset) => {
+      params.push({
+        target: this.poolAddress,
+        callData: WombatPool.poolInterface.encodeFunctionData('isPaused', [
+          token,
+        ]),
+        decodeFunction: booleanDecode,
+      });
+      params.push({
+        target: asset,
+        callData: WombatPool.assetInterface.encodeFunctionData('cash'),
+        decodeFunction: uint120ToBigInt,
+      });
+      params.push({
+        target: asset,
+        callData: WombatPool.assetInterface.encodeFunctionData('liability'),
+        decodeFunction: uint120ToBigInt,
+      });
+      params.push({
+        target: asset,
+        callData: WombatPool.assetInterface.encodeFunctionData(
+          'underlyingTokenDecimals',
+        ),
+        decodeFunction: uint8ToNumber,
+      });
+      params.push({
+        target: asset,
+        callData:
+          WombatPool.assetInterface.encodeFunctionData('getRelativePrice'),
+        decodeFunction: uint256ToBigInt,
+      });
+    });
+
+    return params;
+  }
+
+  protected _parseStateFromMultiResults(
+    multiOutputs: MulticallResultOutputs[],
+  ): PoolState {
+    const [
+      paused,
+      ampFactor,
+      haircutRate,
+      startCovRatio,
+      endCovRatio,
+      tokens,
+      ...remained
+    ] = multiOutputs as [
+      boolean,
+      bigint,
+      bigint,
+      bigint,
+      bigint,
+      Address[],
+      ...MulticallResultOutputs[],
+    ];
+
+    const assetTokenArray = Array.from(this.asset2TokenMap.entries());
+    const token2AssetStates = new Map<Address, AssetState>();
+    _.chunk(remained, 5).forEach((chunk, i) => {
+      const [paused, cash, liability, underlyingTokenDecimals, relativePrice] =
+        chunk as [boolean, bigint, bigint, number, bigint | undefined];
+
+      const [asset, token] = assetTokenArray[i];
+      token2AssetStates.set(token, {
+        address: asset,
+        paused,
+        cash,
+        liability,
+        underlyingTokenDecimals,
+        relativePrice,
+      });
+    });
+
+    const poolState: PoolState = {
+      params: {
+        paused,
+        ampFactor,
+        haircutRate,
+        startCovRatio,
+        endCovRatio,
+      },
+      underlyingAddresses: tokens,
+      asset: {},
+    };
+
+    const isMainPool =
+      Array.from(token2AssetStates.values()).filter(
+        assetState => assetState.relativePrice === undefined,
+      ).length > 0;
+    for (const token of poolState.underlyingAddresses) {
+      if (!token2AssetStates.has(token)) {
+        // this happens when asset has been added to pool but is not added to BMW yet
+        continue;
+      }
+      poolState.asset[token] = token2AssetStates.get(token)!;
+      if (isMainPool) {
+        poolState.asset[token].relativePrice = undefined;
+      }
+    }
+
+    return poolState;
+  }
+
+  public async fetchLatestStateFromRpc(): Promise<ObjWithUpdateInfo<PoolState> | null> {
+    const multiCalls = this.getFetchStateWithBlockInfoMultiCalls();
+    try {
+      const lastUpdatedAtMs = Date.now();
+      const aggregatedResults = (await this.dexHelper.multiWrapper.tryAggregate<
+        number | MulticallResultOutputs
+      >(
+        false,
+        multiCalls as MultiCallParams<MulticallResultOutputs | number>[],
+      )) as [MultiResult<number>, ...MultiResult<MulticallResultOutputs>[]];
+
+      return this.parseStateFromMultiResultsWithBlockInfo(
+        aggregatedResults,
+        lastUpdatedAtMs,
+      );
+    } catch (e) {
+      this._logMessageWithSuppression('ERROR_FETCHING_STATE_FROM_RPC', e);
+    }
+
+    return null;
+  }
+
+  public parseStateFromMultiResultsWithBlockInfo(
+    multiOutputs: [
+      MultiResult<number>,
+      ...MultiResult<MulticallResultOutputs>[],
+    ],
+    lastUpdatedAtMs: number,
+  ): ObjWithUpdateInfo<PoolState> {
+    const [blockNumber, ...outputsForAbstract] = multiOutputs.map((m, i) => {
+      return m.returnData;
+    }) as [number, ...MulticallResultOutputs[]];
+
+    return {
+      value: this._parseStateFromMultiResults(outputsForAbstract),
+      blockNumber,
+      lastUpdatedAtMs,
+    };
+  }
+
+  public addAssets(asset2TokenMap: Map<Address, Address>) {
+    for (const [asset, token] of asset2TokenMap) {
+      if (this.asset2TokenMap.has(asset)) {
+        continue;
+      }
+
+      this.asset2TokenMap.set(asset, token);
+      this._cachedMultiCallData = undefined;
+    }
+  }
+}