@paraswap/dex-lib 3.8.14 → 3.8.16-oswap

package/src/dex/idex.ts

@@ -24,34 +24,7 @@ export type Context = {
   isGlobalDestToken: boolean;
 };
 
-export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
-  needWrapNative: boolean;
-  needsSequentialPreprocessing?: boolean;
-
-  // Returns the ETH fee required to swap
-  // It is optional for a DEX to implement this
-  // This is a legacy function and will be removed soon
-  getNetworkFee?(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    data: ExchangeData,
-    side: SwapSide,
-  ): NumberAsString;
-
-  // If exists, called before getAdapterParam to use async calls and receive data if needed
-  preProcessTransaction?(
-    optimalSwapExchange: OptimalSwapExchange<ExchangeData>,
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): AsyncOrSync<[OptimalSwapExchange<ExchangeData>, ExchangeTxInfo]>;
-
-  // This is helper a function to support testing if preProcessTransaction is implemented
-  getTokenFromAddress?(address: Address): Token;
-
+export interface IDexTxBuilderV5<ExchangeData, DirectParam = null> {
   // Encode params required by the exchange adapter
   // V5: Used for multiSwap, buy & megaSwap
   // V6: NOT used, pass a placeholder
@@ -76,18 +49,6 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     side: SwapSide,
   ): AsyncOrSync<SimpleExchangeParam>;
 
-  getDexParam?(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: ExchangeData,
-    side: SwapSide,
-    context: Context,
-    executorAddress: Address,
-  ): AsyncOrSync<DexExchangeParam>;
-
   // Returns params required by direct swap method.
   // Only Dexes which have a direct method should implement this
   // Used if there is a possibility for direct swap (Eg. UniswapV2,
@@ -108,8 +69,23 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     beneficiary: string,
     contractMethod: string,
   ): TxInfo<DirectParam>;
+}
 
-  // Same as above but for V6
+export interface IDexTxBuilderV6<ExchangeData, DirectParam = null> {
+  // Returns params required by generic method
+  getDexParam?(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: ExchangeData,
+    side: SwapSide,
+    context: Context,
+    executorAddress: Address,
+  ): AsyncOrSync<DexExchangeParam>;
+
+  // Returns params for direct method
   getDirectParamV6?(
     srcToken: Address,
     destToken: Address,
@@ -127,6 +103,37 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
   ): TxInfo<DirectParam>;
 }
 
+export interface IDexTxBuilder<ExchangeData, DirectParam = null>
+  extends IDexTxBuilderV5<ExchangeData, DirectParam>,
+    IDexTxBuilderV6<ExchangeData, DirectParam> {
+  needWrapNative: boolean;
+  needsSequentialPreprocessing?: boolean;
+
+  // Returns the ETH fee required to swap
+  // It is optional for a DEX to implement this
+  // This is a legacy function and will be removed soon
+  getNetworkFee?(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: ExchangeData,
+    side: SwapSide,
+  ): NumberAsString;
+
+  // If exists, called before getAdapterParam to use async calls and receive data if needed
+  preProcessTransaction?(
+    optimalSwapExchange: OptimalSwapExchange<ExchangeData>,
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): AsyncOrSync<[OptimalSwapExchange<ExchangeData>, ExchangeTxInfo]>;
+
+  // This is helper a function to support testing if preProcessTransaction is implemented
+  getTokenFromAddress?(address: Address): Token;
+}
+
 export interface IDexPricing<ExchangeData> {
   readonly dexKey: string;
   // This is true if the the DEX is simply

package/src/dex/index.ts

@@ -81,6 +81,9 @@ import { EtherFi } from './etherfi';
 import { Spark } from './spark/spark';
 import { VelodromeSlipstream } from './uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream';
 import { AaveV3Stata } from './aave-v3-stata/aave-v3-stata';
+import { OSwap } from './oswap/oswap';
+import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
+import { FxProtocolRusd } from './fx-protocol-rusd/fx-protocol-rusd';
 
 const LegacyDexes = [
   CurveV2,
@@ -157,6 +160,9 @@ const Dexes = [
   PharaohV1,
   Spark,
   AaveV3Stata,
+  OSwap,
+  ConcentratorArusd,
+  FxProtocolRusd,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/oswap/config.ts

@@ -0,0 +1,32 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const OSWAP_GAS_COST = 80_000;
+
+// Important:
+//  - All addresses should be lower case.
+//  - Only tokens with 18 decimals are supported.
+export const OSwapConfig: DexConfigMap<DexParams> = {
+  OSwap: {
+    [Network.MAINNET]: {
+      pools: [
+        {
+          id: 'OSwap_0x85b78aca6deae198fbf201c82daf6ca21942acc6', // Pool identifier: `{dex_key}_{pool_address}`
+          address: '0x85b78aca6deae198fbf201c82daf6ca21942acc6', // Address of the pool
+          token0: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', // WETH
+          token1: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84', // STETH
+        },
+      ],
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.MAINNET]: {
+    // Note: We re-use the SmarDex adapters since it implements
+    // an Uniswap V2 router compatible interface, which OSwap supports.
+    [SwapSide.SELL]: [{ name: 'Adapter04', index: 6 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 2 }],
+  },
+};

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

@@ -0,0 +1,91 @@
+/* eslint-disable no-console */
+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';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('Oswap E2E', () => {
+  const dexKey = 'OSwap';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'WETH';
+    const tokenBSymbol: string = 'STETH';
+
+    const tokenAAmount: string = '10000000000000';
+    const tokenBAmount: string = '10000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

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

@@ -0,0 +1,88 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { OSwapConfig } from './config';
+import { OSwapEventPool } from './oswap-pool';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { OSwapPool, OSwapPoolState } from './types';
+
+jest.setTimeout(50 * 1000);
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+// Helper function. Returns the absolute value of the difference between 2 bigints.
+function absdelta(a: bigint, b: bigint) {
+  const delta = a - b;
+  return delta < 0 ? -delta : delta;
+}
+
+function stateCompare(state1: OSwapPoolState, state2: OSwapPoolState) {
+  const ROUNDING_ERROR = 2;
+
+  expect(state1.traderate0).toEqual(state2.traderate0);
+  expect(state1.traderate1).toEqual(state2.traderate1);
+  // Some ERC20 tokens have rounding error which can lead to the balance computed from Transfer event valuee
+  // to deviate by a couple gwei vs the on-chain balance.
+  // For example stETH: https://docs.lido.fi/guides/lido-tokens-integration-guide/#1-2-wei-corner-case
+  expect(absdelta(state1.balance0, state2.balance0)).toBeLessThanOrEqual(
+    ROUNDING_ERROR,
+  );
+  expect(absdelta(state1.balance1, state2.balance1)).toBeLessThanOrEqual(
+    ROUNDING_ERROR,
+  );
+}
+
+describe('Oswap EventPool Mainnet', function () {
+  const dexKey = 'OSwap';
+  const network = Network.MAINNET;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  const pool: OSwapPool = OSwapConfig[dexKey][network].pools[0];
+
+  let eventPool: OSwapEventPool;
+
+  // poolAddress -> EventMappings
+  const eventsToTest: Record<Address, EventMappings> = {
+    [pool.address]: {
+      TraderateChanged: [18917344],
+      Transfer: [18922097, 18924756],
+    },
+  };
+
+  beforeEach(async () => {
+    eventPool = new OSwapEventPool(dexKey, pool, network, dexHelper, logger);
+  });
+
+  Object.entries(eventsToTest).forEach(
+    ([poolAddress, events]: [string, EventMappings]) => {
+      describe(`Events for ${poolAddress}`, () => {
+        Object.entries(events).forEach(
+          ([eventName, blockNumbers]: [string, number[]]) => {
+            describe(`${eventName}`, () => {
+              blockNumbers.forEach((blockNumber: number) => {
+                it(`State after ${blockNumber}`, async function () {
+                  await testEventSubscriber(
+                    eventPool,
+                    eventPool.addressesSubscribed,
+                    (_blockNumber: number) =>
+                      eventPool.generateState(_blockNumber),
+                    blockNumber,
+                    `${dexKey}_${poolAddress}`,
+                    dexHelper.provider,
+                    (state1: OSwapPoolState, state2: OSwapPoolState) =>
+                      stateCompare(state1, state2),
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+});

package/src/dex/oswap/oswap-integration.test.ts

@@ -0,0 +1,269 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { MultiCallParams } from '../../lib/multi-wrapper';
+import { uint256ToBigInt } from '../../lib/decoders';
+import { getBigIntPow } from '../../utils';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Address } from '../../types';
+import { OSwap } from './oswap';
+import { OSwapPool } from './types';
+
+async function getOnchainTraderates(
+  oswap: OSwap,
+  pool: OSwapPool,
+  blockNumber: number,
+): Promise<{ traderate0: bigint; traderate1: bigint }> {
+  const callData: MultiCallParams<bigint>[] = [
+    {
+      target: pool.address,
+      callData: oswap.iOSwap.encodeFunctionData('traderate0', []),
+      decodeFunction: uint256ToBigInt,
+    },
+    {
+      target: pool.address,
+      callData: oswap.iOSwap.encodeFunctionData('traderate1', []),
+      decodeFunction: uint256ToBigInt,
+    },
+  ];
+
+  const results = await oswap.dexHelper.multiWrapper.aggregate<bigint>(
+    callData,
+    blockNumber,
+    oswap.dexHelper.multiWrapper.defaultBatchSize,
+  );
+
+  return { traderate0: results[0], traderate1: results[1] };
+}
+
+// Check prices passed as arguments against prices calculated from on-chain data.
+async function checkOnChainPricing(
+  oswap: OSwap,
+  pool: OSwapPool,
+  blockNumber: number,
+  prices: bigint[],
+  side: SwapSide,
+  srcAddress: Address,
+  destAddress: Address,
+  amounts: bigint[],
+) {
+  // Get the onchain trade rates from the pool and calculate the prices.
+  const data = await getOnchainTraderates(oswap, pool, blockNumber);
+  let expectedPrices: bigint[] = [];
+  for (const amount of amounts) {
+    const rate =
+      srcAddress.toLowerCase() === pool.token0
+        ? data.traderate0
+        : data.traderate1;
+    if (side === SwapSide.SELL) {
+      expectedPrices.push((amount * rate) / getBigIntPow(36));
+    } else {
+      // SwapSide.BUY
+      expectedPrices.push((amount * getBigIntPow(36)) / rate);
+    }
+  }
+  expect(prices).toEqual(expectedPrices);
+}
+
+async function testPricingOnNetwork(
+  oswap: OSwap,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+) {
+  const networkTokens = Tokens[network];
+  const srcToken = networkTokens[srcTokenSymbol];
+  const destToken = networkTokens[destTokenSymbol];
+
+  const poolIds = await oswap.getPoolIdentifiers(
+    srcToken,
+    destToken,
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: ${poolIds}`,
+  );
+
+  expect(poolIds.length).toBeGreaterThan(0);
+
+  // Get calculated prices based on the stored state.
+  const poolPrices = await oswap.getPricesVolume(
+    srcToken,
+    destToken,
+    amounts,
+    side,
+    blockNumber,
+    poolIds,
+  );
+  console.log(
+    `${side} ${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (oswap.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check that the prices calculated from onchain data match with the ones calculated from the stored state.
+  const pool = oswap.getPoolById(poolIds[0]);
+  expect(pool).not.toBeNull();
+  await checkOnChainPricing(
+    oswap,
+    pool as OSwapPool,
+    blockNumber,
+    poolPrices![0].prices,
+    side,
+    srcToken.address,
+    destToken.address,
+    amounts,
+  );
+}
+
+describe('OSwap', function () {
+  const dexKey = 'OSwap';
+  let blockNumber: number;
+  let oswap: OSwap;
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    const srcTokenSymbol = 'WETH';
+    const destTokenSymbol = 'STETH';
+
+    const amountsForSell = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+    ];
+
+    const amountsForBuy = [
+      0n,
+      1n * BI_POWS[tokens[destTokenSymbol].decimals],
+      2n * BI_POWS[tokens[destTokenSymbol].decimals],
+      3n * BI_POWS[tokens[destTokenSymbol].decimals],
+      4n * BI_POWS[tokens[destTokenSymbol].decimals],
+      5n * BI_POWS[tokens[destTokenSymbol].decimals],
+      6n * BI_POWS[tokens[destTokenSymbol].decimals],
+      7n * BI_POWS[tokens[destTokenSymbol].decimals],
+      8n * BI_POWS[tokens[destTokenSymbol].decimals],
+      9n * BI_POWS[tokens[destTokenSymbol].decimals],
+      10n * BI_POWS[tokens[destTokenSymbol].decimals],
+    ];
+
+    // Return a blockNumber to use for the tests.
+    // Check that the pool has enough liquidity to run the tests at the current blockNumber.
+    // If not, fallback to a known blockNumber in the past with
+    // high enough liquidity - the on-chain queries will just be a bit slower to execute.
+    async function getBlockNumberForTesting(oswap: OSwap): Promise<number> {
+      const DEFAULT_BLOCK_NUMBER = 18888241;
+
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const srcToken = Tokens[network][srcTokenSymbol];
+      const destToken = Tokens[network][destTokenSymbol];
+
+      // Get the pool and its state for the given test pair.
+      const pool = oswap.getPoolByTokenPair(srcToken, destToken);
+      if (!pool)
+        throw new Error(
+          `No pool found for pair ${srcTokenSymbol}-${destTokenSymbol}`,
+        );
+
+      const eventPool = oswap.eventPools[pool.id];
+      const state = await eventPool.getStateOrGenerate(blockNumber, true);
+
+      const minBalance =
+        state.balance0 < state.balance1 ? state.balance0 : state.balance1;
+      const maxAmount = [...amountsForSell, ...amountsForBuy].reduce(
+        (max, amount) => (amount > max ? amount : max),
+      );
+      const hasEnoughLiquidity = minBalance > maxAmount;
+
+      if (!hasEnoughLiquidity) {
+        return DEFAULT_BLOCK_NUMBER;
+      }
+      return blockNumber;
+    }
+
+    beforeAll(async () => {
+      oswap = new OSwap(network, dexKey, dexHelper);
+
+      blockNumber = await getBlockNumberForTesting(oswap);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      await testPricingOnNetwork(
+        oswap,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.SELL,
+        amountsForSell,
+      );
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      await testPricingOnNetwork(
+        oswap,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.BUY,
+        amountsForBuy,
+      );
+    });
+
+    it('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const newOSwap = new OSwap(network, dexKey, dexHelper);
+      if (newOSwap.updatePoolState) {
+        await newOSwap.updatePoolState();
+      }
+
+      const poolLiquidity = await newOSwap.getTopPoolsForToken(
+        tokens[srcTokenSymbol].address,
+        10,
+      );
+
+      if (!newOSwap.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][srcTokenSymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
+});