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

package/src/config.ts

@@ -51,7 +51,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     adapterAddresses: {
       Adapter01: '0x9bE264469eF954c139Da4A45Cf76CbCC5e3A6A73',
       Adapter02: '0xFC2Ba6E830a04C25e207B8214b26d8C713F6881F',
-      Adapter03: '0xfb2a3de6c7B8c77b520E3da16021f3D8A4E93168',
+      Adapter03: '0xBAEeb4540f59d30E567a5B563CC0c4587eDd9366',
       Adapter04: '0x654dE10890f8B2C5bF54E50Af169a7E93165C416',
       BuyAdapter: '0x1310dE2C69e9753bee19B5522bad39c5f788efd9',
       BuyAdapter02: '0xA10c9a84E72d9DfF424Fe2284B6460784bed407E',
@@ -165,7 +165,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_56`]?.split(',') || [],
     adapterAddresses: {
       BscAdapter01: '0xA31d9C571DF00e0F428B0bD24c34D103E8112222',
-      BscAdapter02: '0xEECA9223063bD13e8ca77ed9e39a07f2BD1923E6',
+      // BscAdapter02: '0xEECA9223063bD13e8ca77ed9e39a07f2BD1923E6',
+      BscAdapter02: '0x84bEF12C9931cE12662cc9F2366b6a5029E4BD29',
       BscBuyAdapter: '0x301c2813e3ceb43A448a12f21551EDBcdC37F157',
     },
     rpcPollingMaxAllowedStateDelayInBlocks: 1,
@@ -224,7 +225,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     dexalotAuthToken: process.env.API_KEY_DEXALOT_AUTH_TOKEN || '',
     adapterAddresses: {
       AvalancheAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
-      AvalancheAdapter02: '0x2cdB0cDc2a9321ac2ED5b741828a5216C265Be80',
+      AvalancheAdapter02: '0xA10c9a84E72d9DfF424Fe2284B6460784bed407E',
       AvalancheBuyAdapter: '0x9Aa41A24A10af2a965A6D406b913a7Cd9C6886ea',
     },
     uniswapV2ExchangeRouterAddress:
@@ -281,7 +282,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_42161`]?.split(',') || [],
     adapterAddresses: {
       ArbitrumAdapter01: '0xD8134ACfc9c71Ab51452b5bA23A31354F4739032',
-      ArbitrumAdapter02: '0x248009f6F78b5AcD5EA2fc86d56b77A7AeEe2eFc',
+      ArbitrumAdapter02: '0xe9166234DFB6d3ec05C82404109C02Ca82b16c22',
       ArbitrumBuyAdapter: '0xEECA9223063bD13e8ca77ed9e39a07f2BD1923E6',
     },
     uniswapV2ExchangeRouterAddress:
@@ -308,9 +309,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN || '',
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_10`]?.split(',') || [],
-
     adapterAddresses: {
-      OptimismAdapter01: '0x3ad7f275E27AC579cA88e0b4765828242A9E8C49',
+      OptimismAdapter01: '0x5dcf544b0c9689fa67dcb713fd2656d217e25a59',
       OptimismBuyAdapter: '0xfdDD975FE4c1af20c24A3Ad2b33e8609a62DDC73',
     },
     uniswapV2ExchangeRouterAddress:
@@ -366,7 +366,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN || '',
     hashFlowDisabledMMs: [],
     adapterAddresses: {
-      BaseAdapter01: '0x30F6B9b6485ff0B67E881f5ac80D3F1c70A4B23d',
+      BaseAdapter01: '0x654dE10890f8B2C5bF54E50Af169a7E93165C416',
       BaseBuyAdapter: '0xB11bCA7B01b425afD0743A4D77B4f593883f94C0',
     },
     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,
+      };
+    }
+  }
+}