@paraswap/dex-lib 3.7.7-skip-approval.3 → 3.7.8-oswap

package/src/dex/etherfi.ts

@@ -127,7 +127,6 @@ export class EtherFi
 
     // if src token is WETH, we need to withdraw from weth and pass eth value on call. For other cases, we need to approve and perform call
     const isSrcTokenWeth = this.isWETH(srcToken);
-    const skipApproval = this.is_weETH(srcToken) && this.is_eETH(destToken);
 
     return this.buildSimpleParamWithoutWETHConversion(
       isSrcTokenWeth ? ETHER_ADDRESS : srcToken,
@@ -149,7 +148,6 @@ export class EtherFi
             values: ['0'],
           }
         : undefined,
-      skipApproval,
     );
   }
 
@@ -208,8 +206,6 @@ export class EtherFi
       swapFunctionParams,
     );
 
-    const skipApproval = this.is_weETH(srcToken) && this.is_eETH(destToken);
-
     return {
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: false,
@@ -223,7 +219,6 @@ export class EtherFi
           ])
         : undefined,
       returnAmountPos: extractReturnAmountPosition(Interface, swapFunction),
-      skipApproval,
     };
   }
 

package/src/dex/idle-dao/idle-dao.ts

@@ -350,7 +350,6 @@ export class IdleDao extends SimpleExchange implements IDex<IdleDaoData> {
       exchangeData,
       targetExchange: swapCallee,
       returnAmountPos: side === SwapSide.SELL ? returnAmountPos : undefined,
-      skipApproval: data.fromIdleToken,
     };
   }
 

package/src/dex/index.ts

@@ -88,6 +88,7 @@ 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';
 
 const LegacyDexes = [
   CurveV2,
@@ -172,6 +173,7 @@ const Dexes = [
   PharaohV1,
   Spark,
   AaveV3Stata,
+  OSwap,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/mStable.ts

@@ -142,10 +142,6 @@ export class MStable
       destAmount,
       swapData,
       data.exchange,
-      undefined,
-      undefined,
-      undefined,
-      opType === MStableFunctions.redeem,
     );
   }
 }

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,287 @@
+/* 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);
+
+      // Sum up all the amounts from the test scenarios.
+      const sellTotalAmount = amountsForSell.reduce(
+        (a: bigint, b: bigint) => a + b,
+        BigInt(0),
+      );
+      const buyTotalAmount = amountsForBuy.reduce(
+        (a: bigint, b: bigint) => a + b,
+        BigInt(0),
+      );
+
+      if (
+        !oswap.checkLiquidity(
+          pool,
+          state,
+          srcToken,
+          sellTotalAmount,
+          SwapSide.SELL,
+        ) ||
+        !oswap.checkLiquidity(
+          pool,
+          state,
+          destToken,
+          buyTotalAmount,
+          SwapSide.BUY,
+        )
+      ) {
+        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,
+        );
+      }
+    });
+  });
+});