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

package/src/config.ts

@@ -308,9 +308,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN || '',
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_10`]?.split(',') || [],
-
     adapterAddresses: {
-      OptimismAdapter01: '0x654dE10890f8B2C5bF54E50Af169a7E93165C416',
+      OptimismAdapter01: '0x5dcf544b0c9689fa67dcb713fd2656d217e25a59',
       OptimismBuyAdapter: '0xA10c9a84E72d9DfF424Fe2284B6460784bed407E',
     },
     uniswapV2ExchangeRouterAddress:

package/src/dex/index.ts

@@ -38,6 +38,7 @@ import { Excalibur } from './uniswap-v2/excalibur';
 import { MakerPsm } from './maker-psm/maker-psm';
 import { KyberDmm } from './kyberdmm/kyberdmm';
 import { Platypus } from './platypus/platypus';
+import { Wombat } from './wombat/wombat';
 import { GMX } from './gmx/gmx';
 import { WooFiV2 } from './woo-fi-v2/woo-fi-v2';
 import { ParaSwapLimitOrders } from './paraswap-limit-orders/paraswap-limit-orders';
@@ -157,6 +158,7 @@ const Dexes = [
   SwaapV2,
   QuickPerps,
   NomiswapV2,
+  Wombat,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/wombat/config.ts

@@ -0,0 +1,77 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const WombatConfig: DexConfigMap<DexParams> = {
+  Wombat: {
+    [Network.BSC]: {
+      bmwAddress: '0x489833311676B566f888119c29bd997Dc6C95830',
+    },
+    [Network.ARBITRUM]: {
+      bmwAddress: '0x62A83C6791A3d7950D823BB71a38e47252b6b6F4',
+    },
+    [Network.MAINNET]: {
+      bmwAddress: '0xC9bFC3eFeFe4CF96877009F75a61F5c1937e5d1a',
+    },
+    [Network.AVALANCHE]: {
+      bmwAddress: '0x6521a549834F5E6d253CD2e5F4fbe4048f86cd7b',
+    },
+    [Network.BASE]: {
+      bmwAddress: '0x6521a549834F5E6d253CD2e5F4fbe4048f86cd7b',
+    },
+    [Network.OPTIMISM]: {
+      bmwAddress: '0x25C9dd8a3774EF7C918cd28ff59cF9e29504C914',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.BSC]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'BscAdapter02',
+        index: 7,
+      },
+    ],
+  },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'ArbitrumAdapter02',
+        index: 8,
+      },
+    ],
+  },
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'Adapter03',
+        index: 15,
+      },
+    ],
+  },
+  [Network.AVALANCHE]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'AvalancheAdapter02',
+        index: 7,
+      },
+    ],
+  },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'BaseAdapter01',
+        index: 7,
+      },
+    ],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'OptimismAdapter01',
+        index: 12,
+      },
+    ],
+  },
+};

package/src/dex/wombat/types.ts

@@ -0,0 +1,55 @@
+import { Address } from '../../types';
+
+// State-related types
+
+export type BmwState = {
+  pools: Address[];
+};
+
+export type PoolState = {
+  // poolState is the state of event
+  // subscriber. This should be the minimum
+  // set of parameters required to compute
+  // pool prices.
+  params: PoolParams;
+  underlyingAddresses: Address[];
+  asset: { [underlyingAddress: string]: AssetState };
+};
+
+export type AssetState = {
+  address: Address;
+  paused: boolean;
+  cash: bigint;
+  liability: bigint;
+  underlyingTokenDecimals: number;
+  relativePrice?: bigint;
+};
+
+export type PoolParams = {
+  paused: boolean;
+  ampFactor: bigint;
+  haircutRate: bigint;
+  startCovRatio: bigint;
+  endCovRatio: bigint;
+};
+
+export type WombatData = {
+  // TODO: WombatData is the dex data that is
+  // returned by the API that can be used for
+  // tx building. The data structure should be minimal.
+  // Complete me!
+  exchange: Address;
+};
+
+export type DexParams = {
+  // DexParams is set of parameters that can be used to initiate a DEX fork.
+  bmwAddress: Address;
+  // routerAddress?: Address;
+};
+
+export type MulticallResultOutputs =
+  | boolean
+  | bigint
+  | Address
+  | number
+  | undefined;

package/src/dex/wombat/utils.ts

@@ -0,0 +1,62 @@
+import { BI_POWS } from '../../bigint-constants';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { BytesLike } from 'ethers/lib/utils';
+import { generalDecoder } from '../../lib/decoders';
+
+export const WAD = BI_POWS[18];
+
+export function wmul(x: bigint, y: bigint): bigint {
+  return (x * y + WAD / 2n) / WAD;
+}
+
+export function wdiv(x: bigint, y: bigint): bigint {
+  return (x * WAD + y / 2n) / y;
+}
+
+// Convert x to WAD (18 decimals) from d decimals.
+export function toWad(x: bigint, d: bigint): bigint {
+  if (d < 18n) {
+    return x * 10n ** (18n - d);
+  } else if (d > 18n) {
+    return x / 10n ** (d - 18n);
+  }
+  return x;
+}
+// Convert x from WAD (18 decimals) to d decimals.
+export function fromWad(x: bigint, d: bigint): bigint {
+  if (d < 18n) {
+    return x / 10n ** (18n - d);
+  } else if (d > 18n) {
+    return x * 10n ** (d - 18n);
+  }
+  return x;
+}
+
+// Babylonian Method with initial guess (typecast as int)
+export function sqrt(y: bigint, guess: bigint): bigint {
+  let z = 0n;
+  if (y > 3) {
+    if (guess > 0 && guess <= y) {
+      z = guess;
+    } else if (guess < 0 && -guess <= y) {
+      z = -guess;
+    } else {
+      z = y;
+    }
+    let x = (y / z + z) / 2n;
+    while (x != z) {
+      z = x;
+      x = (y / x + x) / 2n;
+    }
+  } else if (y != 0n) {
+    z = 1n;
+  }
+
+  return z;
+}
+
+export const uint120ToBigInt = (
+  result: MultiResult<BytesLike> | BytesLike,
+): bigint => {
+  return generalDecoder(result, ['uint120'], 0n, value => value[0].toBigInt());
+};

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

@@ -0,0 +1,209 @@
+import { Interface } from '@ethersproject/abi';
+import { BytesLike } from 'ethers';
+import { LogDescription } from 'ethers/lib/utils';
+import { Contract } from 'web3-eth-contract';
+import { DeepReadonly } from 'ts-essentials';
+import { Address, Log, Logger, MultiCallInput } from '../../types';
+import { catchParseLogError } from '../../utils';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper';
+import { BmwState } from './types';
+import BmwABI from '../../abi/wombat/bmw.json';
+import AssetABI from '../../abi/wombat/asset.json';
+import PoolABI from '../../abi/wombat/pool.json';
+
+export class WombatBmw extends StatefulEventSubscriber<BmwState> {
+  static readonly bmwInterface = new Interface(BmwABI);
+  static readonly assetInterface = new Interface(AssetABI);
+  static readonly poolInterface = new Interface(PoolABI);
+
+  private readonly logDecoder: (log: Log) => any;
+  private bmwContract: Contract;
+  private handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<BmwState>,
+      log: Readonly<Log>,
+    ) => Promise<DeepReadonly<BmwState> | null>;
+  } = {};
+
+  constructor(
+    dexKey: string,
+    name: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+    protected bmwAddress: Address,
+    protected onAssetAdded: (
+      pool: Address,
+      asset2TokenMap: Map<Address, Address>,
+      blockNumber: number,
+    ) => Promise<void>,
+  ) {
+    super(
+      `${dexKey} ${name}`,
+      `${dexKey}-${network} ${name}`,
+      dexHelper,
+      logger,
+    );
+
+    this.logDecoder = (log: Log) => WombatBmw.bmwInterface.parseLog(log);
+    this.addressesSubscribed = [this.bmwAddress];
+    this.bmwContract = new this.dexHelper.web3Provider.eth.Contract(
+      BmwABI as any,
+      this.bmwAddress,
+    );
+
+    // users-actions handlers
+    this.handlers['Add'] = this.handleAdd.bind(this);
+  }
+
+  /**
+   * The function is called every time any of the subscribed
+   * addresses release log. The function accepts the current
+   * state, updates the state according to the log, and returns
+   * the updated state.
+   * @param state - Current state of event subscriber
+   * @param log - Log released by one of the subscribed addresses
+   * @returns Updates state of the event subscriber after the log
+   */
+  protected async processLog(
+    state: DeepReadonly<BmwState>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<BmwState> | null> {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return await this.handlers[event.name](event, state, log);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
+
+    return null;
+  }
+
+  /**
+   * The function generates state using on-chain calls. This
+   * function is called to regenerate state if the event based
+   * system fails to fetch events and the local state is no
+   * more correct.
+   * should be generated
+   * @returns state of the event subscriber at blocknumber
+   */
+  async generateState(blockNumber: number): Promise<DeepReadonly<BmwState>> {
+    const bmwState: BmwState = { pools: [] };
+    let inputs: MultiCallInput[] = [];
+
+    const poolLength = await this.bmwContract.methods
+      .poolLength()
+      .call({}, blockNumber);
+    for (let i = 0; i < poolLength; i++) {
+      inputs.push({
+        target: this.bmwAddress,
+        callData: WombatBmw.bmwInterface.encodeFunctionData('poolInfo', [i]),
+      });
+    }
+    let returnData = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(inputs)
+        .call({}, blockNumber)
+    ).returnData;
+
+    const lpTokens = returnData.map((data: BytesLike) =>
+      WombatBmw.bmwInterface
+        .decodeFunctionResult('poolInfo', data)[0]
+        .toLowerCase(),
+    );
+
+    inputs = [];
+    for (const lpToken of lpTokens) {
+      inputs.push({
+        target: lpToken,
+        callData:
+          WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
+      });
+      inputs.push({
+        target: lpToken,
+        callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
+      });
+    }
+
+    returnData = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(inputs)
+        .call({}, blockNumber)
+    ).returnData;
+
+    const pool2AssetInfo = new Map<Address, Map<Address, Address>>();
+    let i = 0;
+    for (const lpToken of lpTokens) {
+      const underlyingToken = WombatBmw.assetInterface
+        .decodeFunctionResult('underlyingToken', returnData[i++])[0]
+        .toLowerCase();
+      const pool = WombatBmw.assetInterface
+        .decodeFunctionResult('pool', returnData[i++])[0]
+        .toLowerCase();
+
+      if (!pool2AssetInfo.has(pool)) {
+        pool2AssetInfo.set(pool, new Map<Address, Address>());
+      }
+      pool2AssetInfo.get(pool)!.set(lpToken, underlyingToken);
+    }
+
+    const promises: Promise<void>[] = [];
+    pool2AssetInfo.forEach((asset2TokenMap, pool) => {
+      bmwState.pools.push(pool);
+      promises.push(this.onAssetAdded(pool, asset2TokenMap, blockNumber));
+    });
+    await Promise.all(promises);
+
+    return bmwState;
+  }
+
+  async handleAdd(
+    event: LogDescription,
+    state: DeepReadonly<BmwState>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<BmwState> | null> {
+    const lpToken = event.args.lpToken.toString().toLowerCase();
+    let multiCallInputs: MultiCallInput[] = [];
+
+    multiCallInputs.push({
+      target: lpToken,
+      callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
+    });
+    multiCallInputs.push({
+      target: lpToken,
+      callData: WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
+    });
+
+    const returnData = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(multiCallInputs)
+        .call({}, log.blockNumber)
+    ).returnData;
+
+    const pool = WombatBmw.assetInterface
+      .decodeFunctionResult('pool', returnData[0])[0]
+      .toLowerCase();
+    const underlyingToken = WombatBmw.assetInterface
+      .decodeFunctionResult('underlyingToken', returnData[1])[0]
+      .toLowerCase();
+
+    await this.onAssetAdded(
+      pool,
+      new Map<Address, Address>().set(lpToken, underlyingToken),
+      log.blockNumber,
+    );
+    if (!state.pools.includes(pool)) {
+      return {
+        pools: [...state.pools, pool],
+      };
+    } else {
+      return {
+        pools: state.pools,
+      };
+    }
+  }
+}

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

@@ -0,0 +1,264 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+type Pairs = { name: string; sellAmount: string; buyAmount: string }[][];
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  pairs: Pairs,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy /* ContractMethod.buy */]],
+  ]);
+
+  sideToContractMethods.forEach((contractMethods, side) =>
+    describe(`${side}`, () => {
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        pairs.forEach(pair => {
+          describe(`${contractMethod}`, () => {
+            it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+              await testE2E(
+                tokens[pair[0].name],
+                tokens[pair[1].name],
+                holders[pair[0].name],
+                side === SwapSide.SELL ? pair[0].sellAmount : pair[0].buyAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+
+            it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+              await testE2E(
+                tokens[pair[1].name],
+                tokens[pair[0].name],
+                holders[pair[1].name],
+                side === SwapSide.SELL ? pair[1].sellAmount : pair[1].buyAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      });
+    }),
+  );
+}
+
+describe('Wombat E2E', () => {
+  const dexKey = 'Wombat';
+
+  describe('BSC', () => {
+    const network = Network.BSC;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+      ],
+      [
+        {
+          name: 'BNB',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+        {
+          name: 'BNBx',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+      [
+        {
+          name: 'ETH',
+          sellAmount: '10000000000000000',
+          buyAmount: '10000000000000000',
+        },
+        {
+          name: 'wstETH',
+          sellAmount: '10000000000000000',
+          buyAmount: '10000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Ethereum', () => {
+    const network = Network.MAINNET;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+      [
+        {
+          name: 'ETH',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+        {
+          name: 'wstETH',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '10000000',
+          buyAmount: '10000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '10000000',
+          buyAmount: '10000000',
+        },
+      ],
+      [
+        {
+          name: 'AVAX',
+          sellAmount: '100000000000000000000',
+          buyAmount: '100000000000000000000',
+        },
+        {
+          name: 'sAVAX',
+          sellAmount: '100000000000000000000',
+          buyAmount: '100000000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDbC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Optimism', () => {
+    const network = Network.OPTIMISM;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+});