@paraswap/dex-lib 2.42.28 → 2.42.29-wombat.2

package/src/dex/solidly-v3/types.ts

@@ -0,0 +1,158 @@
+import { BigNumber, BytesLike } from 'ethers';
+import { NumberAsString } from '../../types';
+import { Address } from '../../types';
+import { AbiItem } from 'web3-utils';
+import { MultiResult } from '../../lib/multi-wrapper';
+
+export type FactoryState = Record<string, never>;
+
+export type TickInfo = {
+  liquidityGross: bigint;
+  liquidityNet: bigint;
+  initialized: boolean;
+};
+
+export type Slot0 = {
+  sqrtPriceX96: bigint;
+  tick: bigint;
+  fee: bigint;
+};
+
+export type PoolState = {
+  pool: string;
+  blockTimestamp: bigint;
+  tickSpacing: bigint;
+  slot0: Slot0;
+  liquidity: bigint;
+  maxLiquidityPerTick: bigint;
+  tickBitmap: Record<NumberAsString, bigint>;
+  ticks: Record<NumberAsString, TickInfo>;
+  isValid: boolean;
+  startTickBitmap: bigint;
+  lowestKnownTick: bigint;
+  highestKnownTick: bigint;
+  balance0: bigint;
+  balance1: bigint;
+};
+
+export type SolidlyV3Data = {
+  zeroForOne: boolean;
+  poolAddress: string;
+  isApproved?: boolean;
+};
+
+export type DecodeStateMultiCallFunc = (
+  result: MultiResult<BytesLike> | BytesLike,
+) => DecodedStateMultiCallResultWithRelativeBitmaps;
+
+export type DexParams = {
+  quoter: Address;
+  factory: Address;
+  stateMulticall: Address;
+  supportedTickSpacings: bigint[];
+  chunksCount: number;
+  initRetryFrequency: number;
+  deployer?: Address;
+  subgraphURL: string;
+  initHash: string;
+  stateMultiCallAbi?: AbiItem[];
+  decodeStateMultiCallResultWithRelativeBitmaps?: DecodeStateMultiCallFunc;
+};
+
+export type UniswapV3SimpleSwapSellParam = {
+  path: string;
+  recipient: Address;
+  deadline: string;
+  amountIn: NumberAsString;
+  amountOutMinimum: NumberAsString;
+};
+
+export type UniswapV3SimpleSwapBuyParam = {
+  path: string;
+  recipient: Address;
+  deadline: string;
+  amountOut: NumberAsString;
+  amountInMaximum: NumberAsString;
+};
+
+export type UniswapV3SimpleSwapParams =
+  | UniswapV3SimpleSwapSellParam
+  | UniswapV3SimpleSwapBuyParam;
+
+export type SolidlyV3SimpleSwapParams = {
+  recipient: string;
+  zeroForOne: boolean;
+  amountSpecified: NumberAsString;
+  sqrtPriceLimitX96: NumberAsString;
+};
+
+export type UniswapV3Param = [
+  fromToken: Address,
+  toToken: Address,
+  exchange: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  feePercent: NumberAsString,
+  deadline: NumberAsString,
+  partner: Address,
+  isApproved: boolean,
+  beneficiary: Address,
+  path: string,
+  permit: string,
+  uuid: string,
+];
+
+export enum UniswapV3Functions {
+  exactInput = 'exactInput',
+  exactOutput = 'exactOutput',
+}
+
+export type TickInfoMappings = {
+  index: number;
+  value: TickInfo;
+};
+
+export type TickBitMapMappings = {
+  index: number;
+  value: bigint;
+};
+
+export type OutputResult = {
+  outputs: bigint[];
+  tickCounts: number[];
+};
+
+// Just rewrote every type with BigNumber basically
+
+export type TickBitMapMappingsWithBigNumber = {
+  index: number;
+  value: BigNumber;
+};
+
+export type TickInfoWithBigNumber = {
+  initialized: boolean;
+  liquidityGross: BigNumber;
+  liquidityNet: BigNumber;
+};
+
+export type TickInfoMappingsWithBigNumber = {
+  index: number;
+  value: TickInfoWithBigNumber;
+};
+
+export type DecodedStateMultiCallResultWithRelativeBitmaps = {
+  pool: Address;
+  blockTimestamp: BigNumber;
+  slot0: {
+    sqrtPriceX96: BigNumber;
+    tick: number;
+    fee: number;
+    unlocked: boolean;
+  };
+  liquidity: BigNumber;
+  tickSpacing: number;
+  maxLiquidityPerTick: BigNumber;
+  tickBitmap: TickBitMapMappingsWithBigNumber[];
+  ticks: TickInfoMappingsWithBigNumber[];
+};

package/src/dex/solidly-v3/utils.ts

@@ -0,0 +1,71 @@
+import { BytesLike, ethers } from 'ethers';
+import { assert } from 'ts-essentials';
+import { extractSuccessAndValue } from '../../lib/decoders';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { DexConfigMap } from '../../types';
+import {
+  DexParams,
+  DecodedStateMultiCallResultWithRelativeBitmaps,
+} from './types';
+
+export function getUniswapV3DexKey(UniswapV3Config: DexConfigMap<DexParams>) {
+  const UniswapV3Keys = Object.keys(UniswapV3Config);
+  if (UniswapV3Keys.length !== 1) {
+    throw new Error(
+      `UniswapV3 key in UniswapV3Config is not unique. Update relevant places (optimizer) or fix config issue. Received: ${JSON.stringify(
+        UniswapV3Config,
+        (_0, value) => (typeof value === 'bigint' ? value.toString() : value),
+      )}`,
+    );
+  }
+
+  return UniswapV3Keys[0].toLowerCase();
+}
+
+export function decodeStateMultiCallResultWithRelativeBitmaps(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedStateMultiCallResultWithRelativeBitmaps {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeStateMultiCallResultWithRelativeBitmaps failed to get decodable result: ${result}`,
+  );
+
+  const decoded = ethers.utils.defaultAbiCoder.decode(
+    [
+      // I don't want to pass here any interface, so I just use it in ethers format
+      `
+      tuple(
+        address pool,
+        uint256 blockTimestamp,
+        tuple(
+          uint160 sqrtPriceX96,
+          int24 tick,
+          uint24 fee,
+          bool unlocked,
+        ) slot0,
+        uint128 liquidity,
+        int24 tickSpacing,
+        uint128 maxLiquidityPerTick,
+        tuple(
+          int16 index,
+          uint256 value,
+        )[] tickBitmap,
+        tuple(
+          int24 index,
+          tuple(
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            bool initialized,
+          ) value,
+        )[] ticks
+      )
+    `,
+    ],
+    toDecode,
+  )[0];
+  // This conversion is not precise, because when we decode, we have more values
+  // But I typed only the ones that are used later
+  return decoded as DecodedStateMultiCallResultWithRelativeBitmaps;
+}

package/src/dex/uniswap-v3/uniswap-v3-events.test.ts

@@ -13,6 +13,7 @@ import { Interface } from '@ethersproject/abi';
 import ERC20ABI from '../../abi/erc20.json';
 import StateMulticallABI from '../../abi/uniswap-v3/UniswapV3StateMulticall.abi.json';
 import { AbiItem } from 'web3-utils';
+import { decodeStateMultiCallResultWithRelativeBitmaps } from './utils';
 
 jest.setTimeout(300 * 1000);
 const dexKey = 'UniswapV3';
@@ -100,6 +101,7 @@ describe('UniswapV3 Event', function () {
               StateMulticallABI as AbiItem[],
               config.stateMulticall,
             ),
+            decodeStateMultiCallResultWithRelativeBitmaps,
             new Interface(ERC20ABI),
             config.factory,
             poolFeeCode,
@@ -155,6 +157,7 @@ describe('UniswapV3 Event', function () {
         StateMulticallABI as AbiItem[],
         config.stateMulticall,
       ),
+      decodeStateMultiCallResultWithRelativeBitmaps,
       new Interface(ERC20ABI),
       _config.factory,
       _feeCode,

package/src/dex/wombat/types.ts

@@ -1,3 +1,4 @@
+import { DeepReadonly } from 'ts-essentials';
 import { Address } from '../../types';
 
 // State-related types
@@ -16,6 +17,10 @@ export type PoolState = {
   asset: { [underlyingAddress: string]: AssetState };
 };
 
+export type StateGenerator = (
+  blockNumber: number,
+) => Promise<DeepReadonly<PoolState>>;
+
 export type AssetState = {
   address: Address;
   paused: boolean;

package/src/dex/wombat/utils.ts

@@ -60,3 +60,23 @@ export const uint120ToBigInt = (
 ): bigint => {
   return generalDecoder(result, ['uint120'], 0n, value => value[0].toBigInt());
 };
+
+export function convertUint256ToInt256(uint256Value: bigint): bigint {
+  const isNegative =
+    (uint256Value &
+      BigInt(
+        '0x8000000000000000000000000000000000000000000000000000000000000000',
+      )) !==
+    BigInt(0);
+
+  if (isNegative) {
+    return (
+      uint256Value -
+      BigInt(
+        '0x10000000000000000000000000000000000000000000000000000000000000000',
+      )
+    );
+  } else {
+    return uint256Value;
+  }
+}

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

@@ -10,7 +10,7 @@ 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';
+import PoolABI from '../../abi/wombat/pool-v2.json';
 
 export class WombatBmw extends StatefulEventSubscriber<BmwState> {
   static readonly bmwInterface = new Interface(BmwABI);
@@ -36,13 +36,12 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
     protected bmwAddress: Address,
     protected onAssetAdded: (
       pool: Address,
-      asset2TokenMap: Map<Address, Address>,
       blockNumber: number,
     ) => Promise<void>,
   ) {
     super(
-      `${dexKey} ${name}`,
-      `${dexKey}-${network} ${name}`,
+      `${dexKey}-${name}`,
+      `${dexKey}-${network}-${name}`,
       dexHelper,
       logger,
     );
@@ -118,11 +117,6 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
 
     inputs = [];
     for (const lpToken of lpTokens) {
-      inputs.push({
-        target: lpToken,
-        callData:
-          WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
-      });
       inputs.push({
         target: lpToken,
         callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
@@ -135,26 +129,20 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
         .call({}, blockNumber)
     ).returnData;
 
-    const pool2AssetInfo = new Map<Address, Map<Address, Address>>();
+    const poolAddressSet = new Set<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);
+      poolAddressSet.add(pool);
     }
 
     const promises: Promise<void>[] = [];
-    pool2AssetInfo.forEach((asset2TokenMap, pool) => {
+    poolAddressSet.forEach(pool => {
       bmwState.pools.push(pool);
-      promises.push(this.onAssetAdded(pool, asset2TokenMap, blockNumber));
+      promises.push(this.onAssetAdded(pool, blockNumber));
     });
     await Promise.all(promises);
 
@@ -173,10 +161,6 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
       target: lpToken,
       callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
     });
-    multiCallInputs.push({
-      target: lpToken,
-      callData: WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
-    });
 
     const returnData = (
       await this.dexHelper.multiContract.methods
@@ -187,15 +171,8 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
     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,
-    );
+    await this.onAssetAdded(pool, log.blockNumber);
     if (!state.pools.includes(pool)) {
       return {
         pools: [...state.pools, pool],

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

@@ -172,7 +172,7 @@ describe('Wombat E2E', () => {
           buyAmount: '1000000000000000000',
         },
         {
-          name: 'wstETH',
+          name: 'frxETH',
           sellAmount: '1000000000000000000',
           buyAmount: '1000000000000000000',
         },
@@ -252,6 +252,18 @@ describe('Wombat E2E', () => {
           buyAmount: '100000000',
         },
       ],
+      [
+        {
+          name: 'ETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '100000000000000000',
+        },
+        {
+          name: 'frxETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '100000000000000000',
+        },
+      ],
     ];
 
     testForNetwork(network, dexKey, pairs);

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

@@ -0,0 +1,147 @@
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+import { DeepReadonly } from 'ts-essentials';
+import { WombatPool } from './wombat-pool';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper';
+import { BmwState, PoolState } from './types';
+import { WombatConfig } from './config';
+import { Wombat } from './wombat';
+import { WombatBmw } from './wombat-bmw';
+import { testEventSubscriber } from '../../../tests/utils-events';
+
+jest.setTimeout(100 * 1000);
+
+async function fetchPoolState(
+  wombatPool: WombatPool,
+  blockNumber: number,
+): Promise<DeepReadonly<PoolState>> {
+  return await wombatPool.generateState(blockNumber);
+}
+
+async function fetchBmwState(
+  wombatBmw: WombatBmw,
+  blockNumber: number,
+): Promise<DeepReadonly<BmwState>> {
+  return await wombatBmw.generateState(blockNumber);
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+describe('Wombat EventPool BSC', function () {
+  const dexKey = 'Wombat';
+  const network = Network.BSC;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  const v2Pool = '0x9498563e47D7CFdFa22B818bb8112781036c201C'; // stable guild pool
+  const v3Pool = '0x1ee15673e07105Bcf360139fa8CafeBDd7754BeF'; // cross chain pool
+  const eventsToTest: Record<Address, EventMappings> = {
+    [v2Pool]: {
+      // topic0: 0xf5dd9317b9e63ac316ce44acc85f670b54b339cfa3e9076e1dd55065b922314b
+      ['Deposit']: [34556359, 34556365, 34558365],
+      // topic0: 0xfb80d861da582b723be2d19507ce3e03851820c464abea89156ec77e089b1ad9
+      ['Withdraw']: [34208250, 34262795, 34549292],
+      // topic0: 0x54787c404bb33c88e86f4baf88183a3b0141d0a848e6a9f7a13b66ae3a9b73d1
+      ['Swap']: [34588909, 34590323, 34593343, 34600568, 34602207],
+      ['SetAmpFactor']: [],
+      ['SetHaircutRate']: [],
+      // topic0: 0x0bb5715f0f217c2fe9a0c877ea87d474380c641102f3440ee2a4c8b9d9790918
+      ['AssetAdded']: [28050075],
+      // topic0: 0x0fa1e4606af435f32f05b3804033d2933e691fab32ee74d2db6fa82d2741f1ea
+      ['AssetRemoved']: [34463362],
+      // topic0: 0x4941e18a2bcbb0f9fa0081238f26793a8ad8c202b913ae8bf5f7e523f68ff137
+      ['FillPool']: [],
+      ['Paused']: [34342956],
+      // topic0: 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa
+      ['Unpaused']: [34463362],
+      // topic0: 0xdcb65c0553aaa433aadd180404ff195259c48f78aa50f877ebcb4bb215129a4e
+      ['PausedAsset']: [34463362],
+      ['UnpausedAsset']: [],
+    },
+    [v3Pool]: {
+      // topic0: 0xf5dd9317b9e63ac316ce44acc85f670b54b339cfa3e9076e1dd55065b922314b
+      ['Deposit']: [34558302, 34564573, 34597601],
+      // // topic0: 0xfb80d861da582b723be2d19507ce3e03851820c464abea89156ec77e089b1ad9
+      ['Withdraw']: [34567962, 34569797, 34596990],
+      // // topic0: 0x7fa01e8d24e5a6ec56e00b4ff8ee7ed97e7650a7846ec494bbaa5d65f1be9ea4
+      ['SwapV2']: [34609776, 34610336, 34610364, 34611146, 34611872],
+      // topic0: 0x0fa1e4606af435f32f05b3804033d2933e691fab32ee74d2db6fa82d2741f1ea
+      ['AssetRemoved']: [34463362],
+    },
+  };
+
+  for (const [poolAddress, events] of Object.entries(eventsToTest)) {
+    describe(`Events for ${poolAddress}`, () => {
+      for (const [eventName, blockNumbers] of Object.entries(events)) {
+        describe(`${eventName}`, () => {
+          for (const blockNumber of blockNumbers) {
+            it(`State after ${blockNumber}`, async function () {
+              const wombatPool = new WombatPool(
+                dexKey,
+                poolAddress,
+                network,
+                dexHelper,
+                logger,
+                poolAddress.toLowerCase(),
+              );
+              await wombatPool.initialize(blockNumber - 1);
+
+              await testEventSubscriber(
+                wombatPool,
+                wombatPool.addressesSubscribed,
+                (_blockNumber: number) =>
+                  fetchPoolState(wombatPool, _blockNumber),
+                blockNumber,
+                `${dexKey}_${poolAddress}`,
+                dexHelper.provider,
+              );
+            });
+          }
+        });
+      }
+    });
+  }
+});
+describe('Wombat BMW ARB', function () {
+  const dexKey = 'Wombat';
+  const network = Network.ARBITRUM;
+  const dexHelper = new DummyDexHelper(network);
+  const bmwAddress = WombatConfig.Wombat[network].bmwAddress;
+  const eventsToTest: Record<Address, EventMappings> = {
+    [bmwAddress]: {
+      // topic0: 0xec85b1d1f037ff3a8722aaf5d4d8e7d93c7ff10c056430c18d76a9ec23aa397e
+      ['Add']: [158157042, 162173973],
+    },
+  };
+
+  const wombat = new Wombat(network, dexKey, dexHelper);
+
+  for (const [poolAddress, events] of Object.entries(eventsToTest)) {
+    describe(`Events for ${poolAddress}`, () => {
+      for (const [eventName, blockNumbers] of Object.entries(events)) {
+        describe(`${eventName}`, () => {
+          for (const blockNumber of blockNumbers) {
+            it(`State after ${blockNumber}`, async function () {
+              if (wombat.initializePricing) {
+                await wombat.initializePricing(blockNumber);
+              }
+              await testEventSubscriber(
+                wombat.bmw,
+                wombat.bmw.addressesSubscribed,
+                (_blockNumber: number) =>
+                  fetchBmwState(wombat.bmw, _blockNumber),
+                blockNumber,
+                `${dexKey}_${bmwAddress}`,
+                dexHelper.provider,
+              );
+            });
+          }
+        });
+      }
+    });
+  }
+});