@paraswap/dex-lib 3.8.2 → 3.8.3-integral-dex

package/src/dex/curve-v1-factory/types.ts

@@ -15,7 +15,6 @@ export type PoolContextConstants = {
   // for all pools
   isWrapNative: boolean;
   isLending: boolean;
-  isStable?: boolean;
 
   // Starting from this point, constants are context relevant for pricing
 
@@ -69,15 +68,10 @@ export type PoolStateWithUpdateInfo<T> = {
 };
 
 export type CurveV1FactoryData = {
-  path: {
-    tokenIn: Address;
-    tokenOut: Address;
-    exchange: Address;
-    i: number;
-    j: number;
-    underlyingSwap: boolean;
-    n_coins: number;
-  }[];
+  exchange: Address;
+  i: number;
+  j: number;
+  underlyingSwap: boolean;
   isApproved?: boolean;
 };
 
@@ -124,6 +118,8 @@ export enum FactoryImplementationNames {
   FACTORY_PLAIN_4_OPTIMIZED = 'factory_plain_4_optimized',
 
   FACTORY_STABLE_NG = 'factory_stable_ng',
+  // FACTORY_STABLE_6_NG = 'factory_stable_6_ng',
+  // FACTORY_STABLE_8_NG = 'factory_stable_8_ng',
 }
 
 export enum CustomImplementationNames {
@@ -192,7 +188,6 @@ type DexParamFactory = {
 
 export type DexParams = {
   factories: DexParamFactory[] | null;
-  router: Address;
   stateUpdatePeriodMs: number;
   factoryPoolImplementations: Record<Address, FactoryPoolImplementations>;
   customPools: Record<string, CustomPoolConfig>;
@@ -207,19 +202,8 @@ export enum CurveSwapFunctions {
   exchange_underlying = 'exchange_underlying',
 }
 
-export enum CurveRouterSwapType {
-  exchange = 1,
-  exchange_underlying = 2,
-}
-
-export enum CurveRouterPoolType {
-  non_stable = 0,
-  stable = 10,
-}
-
 export type CurveV1FactoryIfaces = {
   exchangeRouter: Interface;
-  curveV1Router: Interface;
   factory: Interface;
   erc20: Interface;
   threePool: Interface;

package/src/dex/curve-v1-stable-ng/config.ts

@@ -13,7 +13,6 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
-      router: '0x16C6521Dff6baB339122a0FE25a9116693265353', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 5 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -60,18 +59,6 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           liquidityApiSlug: '/factory-stable-ng',
           isStoreRateSupported: true,
         },
-        '0xc65cb3156225380beda366610bab18d5835a1647': {
-          name: ImplementationNames.FACTORY_STABLE_NG,
-          address: '0xc65cb3156225380beda366610bab18d5835a1647',
-          liquidityApiSlug: '/factory-stable-ng',
-          isStoreRateSupported: true,
-        },
-        '0xa0ec67a3c483674f77915893346a8ca3abe2b785': {
-          name: ImplementationNames.FACTORY_STABLE_NG,
-          address: '0xa0ec67a3c483674f77915893346a8ca3abe2b785',
-          liquidityApiSlug: '/factory-stable-ng',
-          isStoreRateSupported: true,
-        },
       },
       customPools: {},
     },
@@ -82,7 +69,6 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
-      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -109,7 +95,6 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
-      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -130,7 +115,6 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
-      router: '0x2191718CD32d02B8E60BAdFFeA33E4B5DD9A0A0D', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -157,7 +141,6 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
-      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -178,7 +161,6 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
-      router: '0x4f37A9d177470499A2dD084621020b023fcffc1F', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),

package/src/dex/curve-v1-stable-ng/curve-v1-stable-ng-e2e.test.ts

@@ -63,23 +63,6 @@ describe('CurveV1StableNG E2E', () => {
         sidesToContractMethods,
       );
     });
-
-    describe('GHO -> crvUSD', () => {
-      const tokenASymbol: string = 'GHO';
-      const tokenBSymbol: string = 'crvUSD';
-
-      const tokenAAmount: string = '1000000000000000000';
-      const tokenBAmount: string = '1000000000000000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-      );
-    });
   });
 
   describe('Polygon', () => {

package/src/dex/index.ts

@@ -2,10 +2,12 @@ import _ from 'lodash';
 import { UnoptimizedRate } from '../types';
 import { CurveV2 } from './curve-v2/curve-v2';
 import { IDexTxBuilder, DexConstructor, IDex, IRouteOptimizer } from './idex';
+import { Jarvis } from './jarvis';
 import { JarvisV6 } from './jarvis-v6/jarvis-v6';
 import { StablePool } from './stable-pool/stable-pool';
 import { Weth } from './weth/weth';
 import { PolygonMigrator } from './polygon-migrator/polygon-migrator';
+import { ZeroX } from './zerox';
 import { UniswapV3 } from './uniswap-v3/uniswap-v3';
 import { BalancerV2 } from './balancer-v2/balancer-v2';
 import { balancerV2Merge } from './balancer-v2/optimizer';
@@ -16,10 +18,15 @@ import { BiSwap } from './uniswap-v2/biswap';
 import { MDEX } from './uniswap-v2/mdex';
 import { Dfyn } from './uniswap-v2/dfyn';
 import { Bancor } from './bancor/bancor';
+import { BProtocol } from './bProtocol/bProtocol';
+import { MStable } from './mStable';
+import { Shell } from './shell';
+import { Onebit } from './onebit/onebit';
 import { Compound } from './compound/compound';
 import { AaveV2 } from './aave-v2/aave-v2';
 import { AaveV3 } from './aave-v3/aave-v3';
 import { IdleDao } from './idle-dao/idle-dao';
+import { OneInchLp } from './OneInchLp';
 import { DodoV1 } from './dodo-v1/dodo-v1';
 import { DodoV2 } from './dodo-v2';
 import { Smoothy } from './smoothy/smoothy';
@@ -55,7 +62,6 @@ import { CurveFork } from './curve-v1/forks/curve-forks/curve-forks';
 import { Swerve } from './curve-v1/forks/swerve/swerve';
 import { CurveV1Factory } from './curve-v1-factory/curve-v1-factory';
 import { CurveV1StableNg } from './curve-v1-stable-ng/curve-v1-stable-ng';
-import { curveV1Merge } from './curve-v1-factory/optimizer';
 import { GenericRFQ } from './generic-rfq/generic-rfq';
 import { WstETH } from './wsteth/wsteth';
 import { Camelot } from './camelot/camelot';
@@ -65,6 +71,7 @@ import { MaverickV1 } from './maverick-v1/maverick-v1';
 import { MaverickV2 } from './maverick-v2/maverick-v2';
 import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ThenaFusion } from './quickswap/thena-fusion';
+import { TraderJoeV2 } from './trader-joe-v2';
 import { SwaapV2 } from './swaap-v2/swaap-v2';
 import { TraderJoeV21 } from './trader-joe-v2.1/trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
@@ -76,6 +83,7 @@ import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 import { Dexalot } from './dexalot/dexalot';
 import { Wombat } from './wombat/wombat';
 import { Swell } from './swell/swell';
+import { Integral } from './integral/integral';
 import { PharaohV1 } from './solidly/forks-override/pharaohV1';
 import { EtherFi } from './etherfi';
 import { Spark } from './spark/spark';
@@ -86,13 +94,21 @@ const LegacyDexes = [
   CurveV2,
   StablePool,
   Smoothy,
+  ZeroX,
   Bancor,
+  BProtocol,
+  MStable,
+  Shell,
+  Onebit,
   Compound,
+  OneInchLp,
   DodoV1,
   DodoV2,
   QuickSwapV3,
   ThenaFusion,
+  TraderJoeV2,
   TraderJoeV21,
+  Jarvis,
   Lido,
   AugustusRFQOrder,
   EtherFi,
@@ -154,6 +170,7 @@ const Dexes = [
   SolidlyV3,
   Wombat,
   Swell,
+  Integral,
   PharaohV1,
   Spark,
   AaveV3Stata,
@@ -188,7 +205,6 @@ export class DexAdapterService {
     balancerV1Merge,
     balancerV2Merge,
     uniswapMerge,
-    curveV1Merge,
   ];
 
   constructor(
@@ -324,7 +340,8 @@ export class DexAdapterService {
     if (this.genericRFQDexKeys.has(dexKey)) {
       return dexKey;
     }
-    if ('uniswapforkoptimized' === dexKey) {
+    if (!isAdapters && /^paraswappool(.*)/i.test(dexKey)) return 'zerox';
+    else if ('uniswapforkoptimized' === dexKey) {
       if (!this.uniswapV2Alias)
         throw new Error(
           `${dexKey} dex is not supported for network(${this.network})!`,

package/src/dex/integral/config.ts

@@ -0,0 +1,20 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network } from '../../constants';
+
+export const IntegralConfig: DexConfigMap<DexParams> = {
+  Integral: {
+    [Network.MAINNET]: {
+      factoryAddress: '0xC480b33eE5229DE3FbDFAD1D2DCD3F3BAD0C56c6',
+      relayerAddress: '0xd17b3c9784510E33cD5B87b490E79253BcD81e2E',
+      subgraphURL: 'ANd5QJuYtyfngmXvBMu9kZAv935vhcqp4xAGBkmCADN3',
+    },
+    [Network.ARBITRUM]: {
+      factoryAddress: '0x717EF162cf831db83c51134734A15D1EBe9E516a',
+      relayerAddress: '0x3c6951FDB433b5b8442e7aa126D50fBFB54b5f42',
+      subgraphURL: 'HXeVedRK7VgogXwbK5Sc4mjyLkhBAS5akskRvbSYnkHU',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {};

package/src/dex/integral/context.ts

@@ -0,0 +1,287 @@
+import { Address } from '@paraswap/core';
+import { IntegralEventPool } from './integral-pool';
+import { IntegralPricing } from './integral-pricing';
+import { IntegralFactory } from './integral-factory';
+import { IntegralRelayer } from './integral-relayer';
+import { Network } from '../../constants';
+import { IDexHelper } from '../../dex-helper';
+import { Logger } from 'log4js';
+import { Interface } from '@ethersproject/abi';
+import {
+  IntegralPool,
+  PoolInitProps,
+  RelayerPoolState,
+  RelayerState,
+  Requires,
+} from './types';
+import { IntegralToken } from './integral-token';
+import { getPoolBackReferencedFrom, getPoolIdentifier } from './utils';
+import _ from 'lodash';
+
+export class IntegralContext {
+  static instances: { [network: number]: IntegralContext } = {};
+
+  pools: { [poolId: string]: IntegralPool } = {};
+  tokens: { [tokenAddress: Address]: IntegralToken } = {};
+  factory: IntegralFactory;
+  relayer: IntegralRelayer;
+
+  logger: Logger;
+
+  private constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    readonly erc20Interface: Interface,
+    readonly factoryAddress: Address,
+    readonly relayerAddress: Address,
+  ) {
+    this.logger = dexHelper.getLogger(dexKey);
+    this.factory = new IntegralFactory(
+      dexHelper,
+      dexKey,
+      this.factoryAddress,
+      this.onPoolCreatedAddPool,
+      this.logger,
+    );
+    this.relayer = new IntegralRelayer(
+      dexHelper,
+      dexKey,
+      this.erc20Interface,
+      this.relayerAddress,
+      {},
+      this.onRelayerPoolEnabledSet,
+      this.logger,
+    );
+  }
+
+  async addPools(
+    pools: PoolInitProps,
+    blockNumber: number,
+    initPhase: boolean = false,
+  ) {
+    this.relayer.addPools(pools);
+    if (initPhase) {
+      await this.relayer.initialize(blockNumber);
+    }
+    const _relayerState = this.relayer.getState(blockNumber);
+    const relayerState = _relayerState
+      ? _relayerState
+      : await this.relayer.generateState(blockNumber);
+    if (!_relayerState) {
+      this.relayer.setState(relayerState, blockNumber);
+    }
+    const poolInitProps = this.removeDisabledPoolInitProps(relayerState, pools);
+
+    const bases = Object.entries(poolInitProps).map(([poolAddress, p]) => {
+      const poolId = getPoolIdentifier(this.dexKey, p.token0, p.token1);
+      const base =
+        (this.pools[poolId] && this.pools[poolId].base) ||
+        new IntegralEventPool(
+          this.dexKey,
+          this.network,
+          this.dexHelper,
+          poolAddress,
+          p.token0,
+          p.token1,
+          this.logger,
+        );
+      this.pools[poolId] = { base, enabled: true };
+      return base;
+    });
+    await Promise.all(
+      bases.map(base => !base.isInitialized && base.initialize(blockNumber)),
+    );
+
+    const pricings = await Promise.all(
+      bases.map(async base => {
+        const _poolState = base.getState(blockNumber);
+        const poolState = _poolState
+          ? _poolState
+          : await base.generateState(blockNumber);
+        const poolId = getPoolIdentifier(this.dexKey, base.token0, base.token1);
+        const pricing =
+          (this.pools[poolId] && this.pools[poolId].pricing) ||
+          new IntegralPricing(
+            this.dexHelper,
+            poolId,
+            this.erc20Interface,
+            poolState.uniswapPool,
+            base.token0,
+            base.token1,
+            poolState.uniswapPoolFee,
+            this.logger,
+            this.network,
+          );
+        this.pools[poolId].pricing = pricing;
+        return pricing;
+      }),
+    );
+    await Promise.all(
+      pricings.map(
+        pricing => !pricing.isInitialized && pricing.initialize(blockNumber),
+      ),
+    );
+
+    const initIntegralToken = (token: Address) =>
+      new IntegralToken(
+        this.network,
+        this.dexHelper,
+        this.dexKey,
+        this.erc20Interface,
+        token,
+        this.relayerAddress,
+        this.onTransferUpdateBalance,
+        this.logger,
+      );
+    bases.map(base => {
+      this.tokens[base.token0] =
+        this.tokens[base.token0] || initIntegralToken(base.token0);
+      this.tokens[base.token1] =
+        this.tokens[base.token1] || initIntegralToken(base.token1);
+    });
+    await Promise.all(
+      Object.values(this.tokens).map(
+        token => !token.isInitialized && token.initialize(blockNumber),
+      ),
+    );
+  }
+
+  getPoolAddresses() {
+    return Object.values(this.pools)
+      .filter(
+        (pool): pool is Requires<IntegralPool, 'base'> =>
+          !!pool.base && pool.enabled,
+      )
+      .map(({ base }) => base.poolAddress);
+  }
+
+  private removeDisabledPoolInitProps(
+    state: RelayerState,
+    props: PoolInitProps,
+  ) {
+    Object.entries(state.pools).forEach(
+      ([poolAddress, poolState]) =>
+        !poolState.isEnabled && delete props[poolAddress],
+    );
+    return props;
+  }
+
+  public static initialize(
+    network: Network,
+    dexKey: string,
+    dexHelper: IDexHelper,
+    erc20Interface: Interface,
+    factoryAddress: Address,
+    relayerAddress: Address,
+  ) {
+    if (!this.instances[network]) {
+      this.instances[network] = new IntegralContext(
+        network,
+        dexKey,
+        dexHelper,
+        erc20Interface,
+        factoryAddress,
+        relayerAddress,
+      );
+    }
+    return this.instances[network];
+  }
+
+  public static getInstance(network: Network) {
+    if (!this.instances[network]) {
+      throw new Error('IntegralContext instance not initialized');
+    }
+    return this.instances[network];
+  }
+
+  async onRelayerPoolEnabledSet(
+    poolAddress: Address,
+    state: RelayerPoolState,
+    blockNumber: number,
+  ) {
+    const poolEntry = getPoolBackReferencedFrom(this, poolAddress);
+    if (state.isEnabled && (!poolEntry || !poolEntry[1].enabled)) {
+      const _factoryState = this.factory.getStaleState();
+      const factoryState = _factoryState
+        ? _factoryState
+        : await this.factory.generateState(blockNumber);
+      const { token0, token1 } = factoryState.pools[poolAddress];
+      await this.addPools({ [poolAddress]: { token0, token1 } }, blockNumber);
+    } else if (!state.isEnabled && poolEntry && poolEntry[1].enabled) {
+      this.pools[poolEntry[0]].enabled = false;
+    }
+  }
+
+  onRebalanceSellOrderExecuted(blockNumber: number, orderId: bigint) {
+    this.relayer.executeOrder(orderId, blockNumber);
+  }
+
+  async onPoolCreatedAddPool(
+    token0: Address,
+    token1: Address,
+    poolAddress: Address,
+    blockNumber: number,
+  ) {
+    await this.addPools({ [poolAddress]: { token0, token1 } }, blockNumber);
+  }
+
+  async onPoolSwapForRelayer(
+    blockNumber: number,
+    poolAddress: Address,
+    recipient: Address,
+    amount0Out: bigint,
+    amount1Out: bigint,
+  ) {
+    if (recipient.toLowerCase() === this.relayerAddress.toLowerCase()) {
+      const pools = this.relayer.getPools();
+      if (pools[poolAddress.toLowerCase()]) {
+        const token0 = pools[poolAddress.toLowerCase()].token0;
+        const token1 = pools[poolAddress.toLowerCase()].token1;
+
+        let _state = this.relayer.getStaleState();
+        if (!_state) {
+          _state = await this.relayer.generateState(blockNumber);
+          this.relayer.setState(_state, blockNumber);
+          return;
+        } else {
+          blockNumber = this.relayer.getStateBlockNumber();
+        }
+
+        const state: RelayerState = _.cloneDeep(_state);
+        if (amount1Out > 0n) {
+          state.tokens[token1].balance += amount1Out;
+        } else {
+          state.tokens[token0].balance += amount0Out;
+        }
+        this.relayer.setState(state, blockNumber);
+      } else {
+        this.logger.error(
+          'Integral Relayer: Pool address not found for',
+          poolAddress,
+        );
+      }
+    }
+  }
+
+  async onTransferUpdateBalance(
+    token: Address,
+    from: Address,
+    to: Address,
+    amount: bigint,
+    blockNumber: number,
+  ) {
+    let _state = this.relayer.getStaleState();
+    if (!_state) {
+      this.logger.error('Integral Token: Relayer stale state not found');
+      return;
+    }
+    const state: RelayerState = _.cloneDeep(_state);
+    if (this.relayer.relayerAddress.toLowerCase() === from) {
+      state.tokens[token].balance -= amount;
+    } else if (this.relayer.relayerAddress.toLowerCase() === to) {
+      state.tokens[token].balance += amount;
+    }
+    this.relayer.setState(state, blockNumber);
+  }
+}

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

@@ -0,0 +1,86 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+jest.setTimeout(1000 * 60 * 3);
+
+const testCases = [
+  {
+    network: Network.MAINNET,
+    side: SwapSide.SELL,
+    method: ContractMethod.swapExactAmountIn,
+    tokenASymbol: 'USDC',
+    tokenBSymbol: 'USDT',
+    tokenAAmount: '5100000000',
+    tokenBAmount: '5100000000',
+  },
+  {
+    network: Network.MAINNET,
+    side: SwapSide.BUY,
+    method: ContractMethod.swapExactAmountOut,
+    tokenASymbol: 'USDC',
+    tokenBSymbol: 'USDT',
+    tokenAAmount: '5100000000',
+    tokenBAmount: '5100000000',
+  },
+  {
+    network: Network.ARBITRUM,
+    side: SwapSide.SELL,
+    method: ContractMethod.swapExactAmountIn,
+    tokenASymbol: 'WETH',
+    tokenBSymbol: 'USDT',
+    tokenAAmount: '1000000000000000000',
+    tokenBAmount: '5100000000',
+  },
+  {
+    network: Network.ARBITRUM,
+    side: SwapSide.BUY,
+    method: ContractMethod.swapExactAmountOut,
+    tokenASymbol: 'WETH',
+    tokenBSymbol: 'USDT',
+    tokenAAmount: '1000000000000000000',
+    tokenBAmount: '5100000000',
+  },
+];
+
+describe('Integral E2E', () => {
+  const dexKey = 'Integral';
+
+  testCases.forEach(
+    ({
+      network,
+      side,
+      method,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    }) => {
+      it(`${network}: ${tokenASymbol} -> ${tokenBSymbol} (${side} ${method})`, async () => {
+        const provider = new StaticJsonRpcProvider(
+          generateConfig(network).privateHttpProvider,
+          network,
+        );
+        const tokens = Tokens[network];
+        const holders = Holders[network];
+
+        await testE2E(
+          tokens[tokenASymbol],
+          tokens[tokenBSymbol],
+          holders[tokenASymbol],
+          side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+          side,
+          dexKey,
+          method,
+          network,
+          provider,
+        );
+      });
+    },
+  );
+});