@paraswap/dex-lib 2.42.16 → 2.42.17-wombat.0

package/src/dex/wombat/wombat.ts

@@ -0,0 +1,426 @@
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import { Interface } from '@ethersproject/abi';
+import { SwapSide } from '@paraswap/core';
+
+import {
+  AdapterExchangeParam,
+  Address,
+  ExchangePrices,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  SimpleExchangeParam,
+  Token,
+} from '../../types';
+import { Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getBigIntPow, getDexKeysWithNetwork, isETHAddress } from '../../utils';
+import { IDex } from '../idex';
+import { IDexHelper } from '../../dex-helper';
+import { DexParams, PoolState, WombatData } from './types';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from '../simple-exchange';
+import { Adapters, WombatConfig } from './config';
+import PoolABI from '../../abi/wombat/pool.json';
+import AssetABI from '../../abi/wombat/asset.json';
+import ERC20ABI from '../../abi/erc20.json';
+import { WombatQuoter } from './wombat-quoter';
+import { WombatBmw } from './wombat-bmw';
+import { fromWad } from './utils';
+import { WombatPool } from './wombat-pool';
+
+export class Wombat extends SimpleExchange implements IDex<WombatData> {
+  // export class Wombat implements IDex<WombatData> {
+  // contract interfaces
+  static readonly erc20Interface = new Interface(ERC20ABI);
+  static readonly poolInterface = new Interface(PoolABI);
+  static readonly assetInterface = new Interface(AssetABI);
+
+  protected config: DexParams;
+  protected poolLiquidityUSD?: { [poolAddress: string]: number };
+  public bmw: WombatBmw;
+  public pools: { [poolAddress: string]: WombatPool } = {};
+
+  readonly hasConstantPriceLargeAmounts = false;
+  readonly needWrapNative = true;
+
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: {
+    key: string;
+    networks: Network[];
+  }[] = getDexKeysWithNetwork(WombatConfig);
+
+  logger: Logger;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    protected adapters = Adapters[network] || {}, // TODO: add any additional optional params to support other fork DEXes
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.config = WombatConfig[dexKey][network];
+    this.bmw = new WombatBmw(
+      dexKey,
+      this.config.bmwAddress,
+      network,
+      dexHelper,
+      this.logger,
+      this.config.bmwAddress,
+      this.onAssetAdded.bind(this),
+    );
+  }
+
+  async init(blockNumber: number) {
+    if (!this.bmw.isInitialized) {
+      await this.bmw.initialize(blockNumber);
+    }
+  }
+
+  // Initialize pricing is called once in the start of
+  // pricing service. It is intended to setup the integration
+  // for pricing requests. It is optional for a DEX to
+  // implement this function
+  async initializePricing(blockNumber: number) {
+    await this.init(blockNumber);
+    const bmwState = this.bmw.getState(blockNumber);
+    if (!bmwState) {
+      throw new Error('initializePricing: bmwState still null after init');
+    }
+  }
+
+  onAssetAdded = async (
+    pool: Address,
+    asset2TokenMap: Map<Address, Address>,
+    blockNumber: number,
+  ): Promise<void> => {
+    if (!this.pools[pool]) {
+      this.pools[pool] = new WombatPool(
+        this.dexKey,
+        this.getPoolIdentifier(pool),
+        this.dexHelper,
+        pool,
+        asset2TokenMap,
+      );
+      await this.pools[pool].getState('latest', true);
+    } else {
+      this.pools[pool].addAssets(asset2TokenMap);
+    }
+  };
+
+  // Returns the list of contract adapters (name and index)
+  // for a buy/sell. Return null if there are no adapters.
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side] ? this.adapters[side] : null;
+  }
+
+  // Returns list of pool identifiers that can be used
+  // for a given swap. poolIdentifiers must be unique
+  // across DEXes. It is recommended to use
+  // ${dexKey}_${poolAddress} as a poolIdentifier
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    await this.updatePoolState();
+    return (
+      await this.findPools(
+        this.dexHelper.config.wrapETH(srcToken).address.toLowerCase(),
+        this.dexHelper.config.wrapETH(destToken).address.toLowerCase(),
+        blockNumber,
+      )
+    ).map(p => this.getPoolIdentifier(p));
+  }
+
+  protected getPoolIdentifier(poolAddress: Address): string {
+    return `${this.dexKey}_${poolAddress}`;
+  }
+
+  // Returns pool prices for amounts.
+  // If limitPools is defined only pools in limitPools
+  // should be used. If limitPools is undefined then
+  // any pools can be used.
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<WombatData>> {
+    if (!this.pools) {
+      this.logger.error(`Missing pools for ${this.dexKey} in getPricesVolume`);
+      return null;
+    }
+    const srcTokenAddress = this.dexHelper.config
+      .wrapETH(srcToken)
+      .address.toLowerCase();
+    const destTokenAddress = this.dexHelper.config
+      .wrapETH(destToken)
+      .address.toLowerCase();
+    if (srcTokenAddress === destTokenAddress) return null;
+
+    const pools = (
+      await this.findPools(srcTokenAddress, destTokenAddress, blockNumber)
+    ).filter(
+      poolAddress =>
+        !limitPools || limitPools.includes(this.getPoolIdentifier(poolAddress)),
+    );
+
+    const promises = [];
+    for (const poolAddress of pools) {
+      let state = await this.pools![poolAddress].getState(blockNumber);
+      if (!state) {
+        this.logger.warn(
+          `State of pool ${poolAddress} is null in getPricesVolume, skipping...`,
+        );
+        continue;
+      }
+      const [unit, ...prices] = this.computePrices(
+        srcTokenAddress,
+        destTokenAddress,
+        [getBigIntPow(srcToken.decimals), ...amounts],
+        side,
+        state.value,
+      );
+      promises.push({
+        prices,
+        unit,
+        data: {
+          exchange: poolAddress,
+        },
+        poolAddresses: [poolAddress],
+        exchange: this.dexKey,
+        /** @todo specify gas cost */
+        gasCost: 260 * 1000,
+        poolIdentifier: this.getPoolIdentifier(poolAddress),
+      });
+    }
+
+    return await Promise.all(promises);
+  }
+
+  // take PoolState to compute price
+  protected computePrices(
+    srcTokenAddress: Address,
+    destTokenAddress: Address,
+    amounts: bigint[],
+    side: SwapSide,
+    state: DeepReadonly<PoolState>,
+  ): bigint[] {
+    const srcAsset = state.asset[srcTokenAddress];
+    const destAsset = state.asset[destTokenAddress];
+    const quoter = new WombatQuoter(state.params);
+
+    return amounts.map(fromAmount => {
+      return side === SwapSide.SELL
+        ? quoter.getQuote(srcAsset, destAsset, fromAmount)
+        : quoter.getQuote(destAsset, srcAsset, -fromAmount);
+    });
+  }
+
+  protected async findPools(
+    srcTokenAddress: Address,
+    destTokenAddress: Address,
+    blockNumber: number,
+  ): Promise<Address[]> {
+    const pools: Address[] = [];
+    for (const [poolAddress, pool] of Object.entries(this.pools)) {
+      let stateOj = await pool.getState(blockNumber);
+      if (!stateOj) {
+        this.logger.warn(
+          `State of pool ${poolAddress} is null in findPools, skipping...`,
+        );
+        continue;
+      }
+
+      const state = stateOj.value;
+      if (
+        state &&
+        !state.params.paused &&
+        state.asset[srcTokenAddress] &&
+        state.asset[destTokenAddress]
+      ) {
+        pools.push(poolAddress);
+      }
+    }
+
+    return pools;
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(poolPrices: PoolPrices<WombatData>): number | number[] {
+    // TODO: update if there is any payload in getAdapterParam
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: WombatData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { exchange } = data;
+
+    return {
+      targetExchange: exchange,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  // Encode call data used by simpleSwap like routers
+  // Used for simpleSwap & simpleBuy
+  // Hint: this.buildSimpleParamWithoutWETHConversion
+  // could be useful
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: WombatData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const { exchange } = data;
+
+    // Encode here the transaction arguments
+    const swapData = Wombat.poolInterface.encodeFunctionData('swap', [
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      this.augustusAddress,
+      getLocalDeadlineAsFriendlyPlaceholder(),
+    ]);
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  // This is called once before getTopPoolsForToken is
+  // called for multiple tokens. This can be helpful to
+  // update common state required for calculating
+  // getTopPoolsForToken. For example, poolLiquidityUSD.
+  async updatePoolState(): Promise<void> {
+    const blockNumber = await this.dexHelper.provider.getBlockNumber();
+    await this.init(blockNumber);
+    const bmwState = this.bmw.getState(blockNumber);
+    if (!bmwState) {
+      throw new Error('updatePoolState: bmwState still null after init');
+    }
+
+    // All tokens are USD stablecoins so to estimate liquidity can just add
+    // the cash balances of all the tokens
+    const poolLiquidityUSD: { [poolAddress: string]: number } = {};
+    const usdPromises = [];
+    const poolStates: { [poolAddress: string]: DeepReadonly<PoolState> } = {};
+    const poolStateObjs = await Promise.all(
+      Object.values(this.pools).map(pool => pool.getState()),
+    );
+
+    for (const [poolAddress, pool] of Object.entries(this.pools)) {
+      const index = Object.keys(this.pools).indexOf(poolAddress);
+      let state = poolStateObjs[index];
+      if (!state) {
+        this.logger.warn(
+          `State of ${poolAddress} is null in updatePoolState, skipping...`,
+        );
+        continue;
+      }
+      poolStates[poolAddress] = state.value;
+      for (const [tokenAddress, assetState] of Object.entries(
+        state.value.asset,
+      )) {
+        usdPromises.push(
+          this.dexHelper.getTokenUSDPrice(
+            {
+              address: tokenAddress,
+              decimals: assetState.underlyingTokenDecimals,
+            },
+            fromWad(
+              assetState.cash,
+              BigInt(assetState.underlyingTokenDecimals),
+            ),
+          ),
+        );
+      }
+    }
+    const usdValues = await Promise.all(usdPromises);
+
+    for (const [poolAddress, poolState] of Object.entries(poolStates)) {
+      poolLiquidityUSD[poolAddress] = 0;
+      for (let i = 0; i < poolState.underlyingAddresses.length; i++) {
+        poolLiquidityUSD[poolAddress] += usdValues[i];
+      }
+    }
+
+    this.poolLiquidityUSD = poolLiquidityUSD;
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.poolLiquidityUSD) await this.updatePoolState();
+    tokenAddress = (
+      isETHAddress(tokenAddress)
+        ? this.dexHelper.config.data.wrappedNativeTokenAddress
+        : tokenAddress
+    ).toLowerCase();
+    const pools: string[] = [];
+    const poolStates: { [poolAddress: string]: DeepReadonly<PoolState> } = {};
+    for (const [poolAddress, eventPool] of Object.entries(this.pools)) {
+      let state = await eventPool.getState();
+      if (!state) {
+        this.logger.warn(
+          `State of ${poolAddress} is null in getTopPoolsForToken, skipping...`,
+        );
+        continue;
+      }
+      if (
+        state.value.underlyingAddresses.includes(tokenAddress) &&
+        this.poolLiquidityUSD![poolAddress]
+      ) {
+        poolStates[poolAddress] = state.value;
+        pools.push(poolAddress);
+      }
+    }
+
+    // sort by liquidity
+    pools.sort((a, b) => this.poolLiquidityUSD![b] - this.poolLiquidityUSD![a]);
+    return pools.slice(0, limit).map(poolAddress => ({
+      exchange: this.dexKey,
+      address: poolAddress,
+      // other tokens in the same pool
+      connectorTokens: poolStates[poolAddress].underlyingAddresses
+        .filter(t => t !== tokenAddress)
+        .map(t => ({
+          decimals: poolStates[poolAddress].asset[t].underlyingTokenDecimals,
+          address: t,
+        })),
+      liquidityUSD: this.poolLiquidityUSD![poolAddress],
+    }));
+  }
+
+  // This is optional function in case if your implementation has acquired any resources
+  // you need to release for graceful shutdown. For example, it may be any interval timer
+  releaseResources(): AsyncOrSync<void> {
+    // TODO: complete me!
+  }
+}

package/tests/constants-e2e.ts

@@ -550,6 +550,10 @@ export const Tokens: {
       address: '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c',
       decimals: 18,
     },
+    BNBx: {
+      address: '0x1bdd3Cf7F79cfB8EdbB955f20ad99211551BA275',
+      decimals: 18,
+    },
     BUSD: {
       address: '0xe9e7cea3dedca5984780bafc599bd69add087d56',
       decimals: 18,
@@ -764,6 +768,10 @@ export const Tokens: {
     },
   },
   [Network.ARBITRUM]: {
+    SEN: {
+      address: '0x154388a4650D63acC823e06Ef9e47C1eDdD3cBb2',
+      decimals: 18,
+    },
     DAI: {
       address: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
       decimals: 18,
@@ -849,6 +857,10 @@ export const Tokens: {
       address: '0x3d9907f9a368ad0a51be60f7da3b97cf940982d8',
       decimals: 18,
     },
+    wstETH: {
+      address: '0x5979D7b546E38E414F7E9822514be443A4800529',
+      decimals: 18,
+    },
   },
   [Network.OPTIMISM]: {
     DAI: {
@@ -1105,6 +1117,7 @@ export const Holders: {
     FRAX: '0xEB4576fE753DAB07635c0Bb6c8f0A355e1Db5d31',
     frxETH: '0xf324adC872005197A6f7DAE214d3b63aa0C3625F',
     USDFI: '0x2E00D722e091836B39Db3e4dcE6eE51c90c5B221',
+    BNBx: '0xFF4606bd3884554CDbDabd9B6e25E2faD4f6fc54',
   },
   [Network.AVALANCHE]: {
     AVAX: '0xD6216fC19DB775Df9774a6E33526131dA7D19a2c',
@@ -1140,14 +1153,16 @@ export const Holders: {
     BTCb: '0x84c06d3c27821d0136f66306f5028d43ceac268d',
   },
   [Network.ARBITRUM]: {
+    SEN: '0xcb19b6b4971bd4206bab176c75b1efe3e28ee5a8',
+    RDPX: '0x2fa6f21ecfe274f594f470c376f5bdd061e08a37',
     ARB: '0xb65edba80a3d81903ecd499c8eb9cf0e19096bd0',
     ETH: '0xF977814e90dA44bFA03b6295A0616a897441aceC',
     DAI: '0x07d7f291e731a41d3f0ea4f1ae5b6d920ffb3fe0',
     WETH: '0xc31e54c7a869b9fcbecc14363cf510d1c41fa443',
     USDCe: '0x62383739d68dd0f844103db8dfb05a7eded5bbe6',
-    USDC: '0xa843392198862f98d17e3aa1421b08f2c2020cff',
+    USDC: '0xb38e8c17e38363af6ebdcb3dae12e0243582891d',
     OHM: '0xebce5f29ff5ca9aa330ebdf7ec6b5f474bff271e',
-    USDT: '0x5ff47d4ab75bcaff6807c81f1367abb53439883c',
+    USDT: '0xf977814e90da44bfa03b6295a0616a897441acec',
     POPS: '0x4b78b52e7de4d8b7d367297cb8a87c1875a9d591',
     FRAX: '0x59bf0545fca0e5ad48e13da269facd2e8c886ba4',
     nUSD: '0x9dd329f5411466d9e0c488ff72519ca9fef0cb40',
@@ -1162,14 +1177,15 @@ export const Holders: {
     ZYB: '0x3ec0eddcd1e25025077327886a78133589082fb2',
     WBTC: '0xd9d611c6943585bc0e18e51034af8fa28778f7da',
     RDNT: '0x62383739d68dd0f844103db8dfb05a7eded5bbe6',
+    wstETH: '0x916792f7734089470de27297903bed8a4630b26d',
   },
   [Network.OPTIMISM]: {
     ETH: '0x9ef21bE1C270AA1c3c3d750F458442397fBFFCB6',
     DAI: '0x1337bedc9d22ecbe766df105c9623922a27963ec',
     WETH: '0x68F5C0A2DE713a54991E01858Fd27a3832401849',
     POPS: '0x3cbd9044aaabef08ce93a68448e093cff405ad76',
-    USDC: '0xEBb8EA128BbdFf9a1780A4902A9380022371d466',
-    USDT: '0xEBb8EA128BbdFf9a1780A4902A9380022371d466',
+    USDC: '0xdecc0c09c3b5f6e92ef4184125d5648a66e35298',
+    USDT: '0xf977814e90da44bfa03b6295a0616a897441acec',
     OP: '0xEBb8EA128BbdFf9a1780A4902A9380022371d466',
     aOptWETH: '0x7B7D80C40415F744864f051B806b466e2fbB8E68',
     aOptUSDC: '0x8c0Fcf914E90fF5d7f2D02c1576BF4245FaD2B7F',

package/tests/utils-e2e.ts

@@ -35,6 +35,7 @@ import { SmartToken, StateOverrides } from './smart-tokens';
 import { GIFTER_ADDRESS } from './constants-e2e';
 import { generateDeployBytecode, sleep } from './utils';
 import { assert } from 'ts-essentials';
+import * as util from 'util';
 
 export const testingEndpoint = process.env.E2E_TEST_ENDPOINT;
 
@@ -84,7 +85,7 @@ const MULTISIG: { [nid: number]: string } = {
   [Network.POLYGON]: '0x46DF4eb6f7A3B0AdF526f6955b15d3fE02c618b7',
   [Network.FANTOM]: '0xECaB2dac955b94e49Ec09D6d68672d3B397BbdAd',
   [Network.AVALANCHE]: '0x1e2ECA5e812D08D2A7F8664D69035163ff5BfEC2',
-  [Network.OPTIMISM]: '0xf01121e808F782d7F34E857c27dA31AD1f151b39',
+  [Network.OPTIMISM]: '0x3b28A6f6291f7e8277751f2911Ac49C585d049f6',
   [Network.ARBITRUM]: '0x90DfD8a6454CFE19be39EaB42ac93CD850c7f339',
   [Network.BASE]: '0x6C674c8Df1aC663b822c4B6A56B4E5e889379AE0',
 };