@paraswap/dex-lib 3.8.23 → 3.8.25

package/src/dex/infusion/utils/isStablePair.ts

@@ -0,0 +1,18 @@
+import { Network } from '../../../constants';
+
+export const stablecoins: Record<number, string[]> = {
+  [Network.BASE]: [
+    '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'.toLowerCase(), // usdc
+    '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA'.toLowerCase(), // usdbc
+    '0xEB466342C4d449BC9f53A865D5Cb90586f405215'.toLowerCase(), // axelar usdc
+  ],
+};
+
+export function isStablePair(chainId: number, tokenA: string, tokenB: string) {
+  const stables = stablecoins[chainId];
+
+  return (
+    stables.includes(tokenA.toLocaleLowerCase()) &&
+    stables.includes(tokenB.toLocaleLowerCase())
+  );
+}

package/src/dex/lite-psm/lite-psm.ts

@@ -242,7 +242,7 @@ export class LitePsm
         },
         poolAddresses: [eventPool.poolConfig.psmAddress],
         exchange: this.dexKey,
-        gasCost: isSrcDai ? 80_000 : 100_000,
+        gasCost: 50000,
         poolIdentifier,
       },
     ];
@@ -450,10 +450,7 @@ export class LitePsm
       // not used on the contract, but used for analytics
       destToken,
       fromAmount,
-      // TODO: Investigate `toAmount` vs `quotedAmount`
-      side === SwapSide.BUY && srcToken.toLowerCase() === this.dai.address
-        ? toAmount
-        : quotedAmount,
+      toAmount,
       data.toll,
       to18ConversionFactor.toString(),
       data.psmAddress,

package/src/dex/maker-psm/maker-psm.ts

@@ -397,7 +397,7 @@ export class MakerPsm
         },
         poolAddresses: [eventPool.poolConfig.psmAddress],
         exchange: this.dexKey,
-        gasCost: 100 * 1000, //TODO: simulate and fix the gas cost
+        gasCost: 200 * 1000,
         poolIdentifier,
       },
     ];
@@ -653,11 +653,7 @@ export class MakerPsm
       // not used on the contract, but used for analytics
       destToken,
       fromAmount,
-      // as there's no slippage, use instead of toAmount
-      // TODO: Investigate `toAmount` vs `quotedAmount`
-      side === SwapSide.BUY && srcToken.toLowerCase() === this.dai.address
-        ? toAmount
-        : quotedAmount,
+      toAmount,
       data.toll,
       to18ConversionFactor.toString(),
       data.psmAddress,

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(BigInt(state1.balance0), BigInt(state2.balance0)),
+  ).toBeLessThanOrEqual(ROUNDING_ERROR);
+  expect(
+    absdelta(BigInt(state1.balance1), BigInt(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,291 @@
+/* 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 = BigInt(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 ${srcTokenSymbol}`, async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const newOSwap = new OSwap(network, dexKey, dexHelper);
+      await newOSwap.updatePoolState?.();
+
+      const poolLiquidity = await newOSwap.getTopPoolsForToken(
+        tokens[srcTokenSymbol].address,
+        10,
+      );
+
+      console.log(`${srcTokenSymbol} top pools:`, poolLiquidity);
+
+      if (!newOSwap.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][srcTokenSymbol].address,
+          dexKey,
+        );
+      }
+    });
+
+    it(`getTopPoolsForToken ${destTokenSymbol}`, async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const newOSwap = new OSwap(network, dexKey, dexHelper);
+      await newOSwap.updatePoolState?.();
+
+      const poolLiquidity = await newOSwap.getTopPoolsForToken(
+        tokens[destTokenSymbol].address,
+        10,
+      );
+
+      console.log(`${destTokenSymbol} top pools:`, poolLiquidity);
+
+      if (!newOSwap.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][destTokenSymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
+});