@paraswap/dex-lib 2.50.6 → 2.50.7-sdai

package/src/config.ts

@@ -55,8 +55,9 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       Adapter03: '0xBAEeb4540f59d30E567a5B563CC0c4587eDd9366',
       Adapter04: '0x369A2FDb910d432f0a07381a5E3d27572c876713',
       Adapter05: '0x3329dfa55A40B450952FBE0203167Ae6908E656d',
+      Adapter06: '0xe9166234DFB6d3ec05C82404109C02Ca82b16c22',
       BuyAdapter: '0x84bEF12C9931cE12662cc9F2366b6a5029E4BD29',
-      BuyAdapter02: '0xe53d24CD81cC81bbf271AD7B02D0d67f851D727c',
+      BuyAdapter02: '0x40dB7541b0c655a3a70c4713aD6879Ec3861c1FE',
     },
     uniswapV2ExchangeRouterAddress:
       '0xF9234CB08edb93c0d4a4d4c70cC3FfD070e78e07',
@@ -288,10 +289,12 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     swaapV2AuthToken: process.env.API_KEY_SWAAP_V2_AUTH_TOKEN || '',
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_42161`]?.split(',') || [],
+    dexalotAuthToken: process.env.API_KEY_DEXALOT_AUTH_TOKEN || '',
     adapterAddresses: {
       ArbitrumAdapter01: '0x369A2FDb910d432f0a07381a5E3d27572c876713',
       ArbitrumAdapter02: '0x58a5f0b73969800FAFf8556cD2187E3FCE71A6cb',
-      ArbitrumBuyAdapter: '0x4483Ae378897eB9FbF7f15Df98Bf07233ffFEe8b',
+      ArbitrumAdapter03: '0x97bdD2B98D9802b0e387FefdB2882C1b2dc2c344',
+      ArbitrumBuyAdapter: '0x005213c48d4aafFcA0b6D1CbA8710F4D035C18f9',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',

package/src/dex/dexalot/config.ts

@@ -7,6 +7,9 @@ export const DexalotConfig: DexConfigMap<DexParams> = {
     [Network.AVALANCHE]: {
       mainnetRFQAddress: '0xEed3c159F3A96aB8d41c8B9cA49EE1e5071A7cdD',
     },
+    [Network.ARBITRUM]: {
+      mainnetRFQAddress: '0x010224949cCa211Fb5dDfEDD28Dc8Bf9D2990368',
+    },
   },
 };
 
@@ -15,4 +18,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 6 }],
     [SwapSide.BUY]: [{ name: 'AvalancheBuyAdapter', index: 8 }],
   },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter03', index: 2 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 11 }],
+  },
 };

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

@@ -196,7 +196,7 @@ describe('Dexalot E2E', () => {
     const tokenASymbol: string = 'BTCb';
     const tokenBSymbol: string = 'USDC';
 
-    const tokenAAmount: string = '100';
+    const tokenAAmount: string = '10000';
     const tokenBAmount: string = '9000000000';
     const nativeTokenAmount = '1000000000000000000';
 
@@ -211,4 +211,26 @@ describe('Dexalot E2E', () => {
       true,
     );
   });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+
+    const tokenASymbol: string = 'USDT';
+    const tokenBSymbol: string = 'USDC';
+
+    const tokenAAmount: string = '1000000';
+    const tokenBAmount: string = '1000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+      true,
+    );
+  });
 });

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

@@ -185,4 +185,125 @@ describe('Dexalot', function () {
       }
     });
   });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    const tokenASymbol = 'USDT';
+    const tokenBSymbol = 'USDC';
+
+    const amountsForTokenA = [
+      0n,
+      1n * BI_POWS[tokens[tokenASymbol].decimals],
+      2n * BI_POWS[tokens[tokenASymbol].decimals],
+      3n * BI_POWS[tokens[tokenASymbol].decimals],
+      4n * BI_POWS[tokens[tokenASymbol].decimals],
+      5n * BI_POWS[tokens[tokenASymbol].decimals],
+      6n * BI_POWS[tokens[tokenASymbol].decimals],
+      7n * BI_POWS[tokens[tokenASymbol].decimals],
+      8n * BI_POWS[tokens[tokenASymbol].decimals],
+      9n * BI_POWS[tokens[tokenASymbol].decimals],
+      10n * BI_POWS[tokens[tokenASymbol].decimals],
+    ];
+
+    const amountsForTokenB = [
+      0n,
+      1n * BI_POWS[tokens[tokenBSymbol].decimals],
+      2n * BI_POWS[tokens[tokenBSymbol].decimals],
+      3n * BI_POWS[tokens[tokenBSymbol].decimals],
+      4n * BI_POWS[tokens[tokenBSymbol].decimals],
+      5n * BI_POWS[tokens[tokenBSymbol].decimals],
+      6n * BI_POWS[tokens[tokenBSymbol].decimals],
+      7n * BI_POWS[tokens[tokenBSymbol].decimals],
+      8n * BI_POWS[tokens[tokenBSymbol].decimals],
+      9n * BI_POWS[tokens[tokenBSymbol].decimals],
+      10n * BI_POWS[tokens[tokenBSymbol].decimals],
+    ];
+
+    beforeEach(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      dexalot = new Dexalot(network, dexKey, dexHelper);
+      await dexalot.initializePricing(blockNumber);
+      await sleep(5000);
+    });
+
+    afterEach(async () => {
+      dexalot.releaseResources();
+      await sleep(5000);
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.SELL,
+        amountsForTokenA,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.BUY,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.SELL,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.BUY,
+        amountsForTokenA,
+      );
+    });
+
+    it('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const dexalot = new Dexalot(network, dexKey, dexHelper);
+      const poolLiquidity = await dexalot.getTopPoolsForToken(
+        tokens[tokenASymbol].address,
+        10,
+      );
+      console.log(`${tokenASymbol} Top Pools:`, poolLiquidity);
+
+      if (!dexalot.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][tokenASymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
 });

package/src/dex/index.ts

@@ -87,6 +87,7 @@ import { Wombat } from './wombat/wombat';
 import { Swell } from './swell/swell';
 import { PharaohV1 } from './solidly/forks-override/pharaohV1';
 import { EtherFi } from './etherfi';
+import { SDai } from './sdai/sdai';
 
 const LegacyDexes = [
   CurveV2,
@@ -170,6 +171,7 @@ const Dexes = [
   Wombat,
   Swell,
   PharaohV1,
+  SDai,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/sdai/config.ts

@@ -0,0 +1,28 @@
+import { SDaiParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+import { SwapSide } from '@paraswap/core';
+
+export const SDaiConfig: DexConfigMap<SDaiParams> = {
+  SDai: {
+    [Network.MAINNET]: {
+      sdaiAddress: '0x83F20F44975D03b1b09e64809B757c47f942BEeA',
+      daiAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+      potAddress: '0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7',
+    },
+  },
+};
+
+export const Adapters: {
+  [chainId: number]: {
+    [side: string]: { name: string; index: number }[];
+  };
+} = {
+  [Network.MAINNET]: {
+    // TODO: uncomment this when SDAI integration got deployed
+    // [SwapSide.SELL]: [{ name: 'Adapter06', index: 2 }],
+    // [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 5 }],
+    [SwapSide.SELL]: [{ name: 'Adapter06', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 4 }],
+  },
+};

package/src/dex/sdai/constants.ts

@@ -0,0 +1,2 @@
+export const SDAI_DEPOSIT_GAS_COST = 165_000;
+export const SDAI_REDEEM_GAS_COST = 90_000;

package/src/dex/sdai/scripts/validate-state.ts

@@ -0,0 +1,144 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Network } from '../../../constants';
+import { DummyDexHelper } from '../../../dex-helper';
+import { SDaiPoolState } from '../types';
+import { BlockHeader } from 'web3-eth';
+import { ethers } from 'ethers';
+import { SDai } from '../sdai';
+import { SDaiConfig } from '../config';
+import { getOnChainState } from '../utils';
+import { Interface } from '@ethersproject/abi';
+import PotAbi from '../../../abi/maker-psm/pot.json';
+
+const network = Network.MAINNET;
+const dexKey = 'SDai';
+
+const { potAddress } = SDaiConfig[dexKey][network];
+const blockHeaders: Record<number, BlockHeader> = {};
+
+const dexHelper = new DummyDexHelper(network);
+const logger = dexHelper.getLogger(dexKey);
+
+function preprocessField(value: any): string {
+  if (
+    typeof value === 'bigint' ||
+    typeof value === 'number' ||
+    ethers.BigNumber.isBigNumber(value)
+  ) {
+    return value.toString();
+  }
+  return value;
+}
+
+function compareAndLogDifferences<T extends object, Y extends object>(
+  obj1: T,
+  obj2: Y,
+  keyNames: Array<keyof T & keyof Y>,
+  checkEachKey = false,
+) {
+  let isValid = true;
+  let keys = keyNames;
+
+  if (checkEachKey) {
+    // find common keys
+    const keys1 = Object.keys(obj1);
+    const keys2 = new Set(Object.keys(obj2));
+    keys = keys1.filter(key => keys2.has(key)) as Array<keyof T & keyof Y>;
+  }
+
+  for (let fieldName of keys) {
+    const value1 = preprocessField(obj1[fieldName]);
+    const value2 = preprocessField(obj2[fieldName]);
+
+    if (value1 !== value2) {
+      console.log(
+        `${fieldName.toString()} mismatch: actual: ${value1} vs pool: ${value2}`,
+      );
+      isValid = false;
+    }
+  }
+
+  return isValid;
+}
+
+async function isPoolStateEqualToReal(
+  state: SDaiPoolState,
+  blockNumber: number,
+) {
+  const expected = await getOnChainState(
+    dexHelper.multiContract,
+    potAddress,
+    new Interface(PotAbi),
+    blockNumber,
+  );
+
+  const isValidState = compareAndLogDifferences(state, expected, [
+    'rho',
+    'dsr',
+    'dsr',
+  ]);
+
+  return isValidState;
+}
+
+async function checkPoolStateForBlockRange(
+  startBlockNumber: number,
+  endBlockNumber: number,
+): Promise<boolean> {
+  const network = Network.MAINNET;
+  const dexKey = 'SDai';
+  const dexHelper = new DummyDexHelper(network);
+
+  const sdai = new SDai(network, dexKey, dexHelper);
+  const pool = await sdai.eventPool;
+
+  const logsToDispatch = await dexHelper.provider.getLogs({
+    fromBlock: startBlockNumber,
+    toBlock: endBlockNumber,
+    address: potAddress,
+  });
+
+  console.log(logsToDispatch.length);
+
+  // group logs by block number
+  const logsByBlockNumber: Record<number, any[]> = {};
+  for (let log of logsToDispatch) {
+    if (!logsByBlockNumber[log.blockNumber]) {
+      logsByBlockNumber[log.blockNumber] = [];
+    }
+    logsByBlockNumber[log.blockNumber].push(log);
+  }
+
+  const sortedBlocks = Object.keys(logsByBlockNumber)
+    .map(Number)
+    .sort((a, b) => Number(a) - Number(b));
+
+  for (let blockNumber of sortedBlocks) {
+    if (!blockHeaders[blockNumber]) {
+      blockHeaders[blockNumber] = await dexHelper.web3Provider.eth.getBlock(
+        blockNumber,
+      );
+    }
+
+    await pool?.update(logsByBlockNumber[blockNumber], {
+      [blockNumber]: blockHeaders[blockNumber],
+    });
+  }
+
+  const state = pool?.getState(startBlockNumber) as SDaiPoolState;
+  return isPoolStateEqualToReal(state, endBlockNumber);
+}
+
+async function main() {
+  // use findBreakingBlock to find the block where the state is broken
+  // console.log(await findBreakingBlock(startBlockNumber, endBlockNumber));
+  // previously broken block 150502863
+  console.log(await checkPoolStateForBlockRange(19199247 - 10000, 19199247));
+}
+
+main()
+  .then(() => console.log('Done'))
+  .catch(e => console.error(e));

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

@@ -0,0 +1,96 @@
+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.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+  ]);
+
+  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('sDAI E2E', () => {
+  const dexKey = 'sdai';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'DAI';
+    const tokenBSymbol: string = 'sDAI';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

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

@@ -0,0 +1,105 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { SDaiEventPool } from './sdai-pool';
+import { SDaiConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { SDaiPoolState } from './types';
+
+import PotAbi from '../../abi/maker-psm/pot.json';
+import { Interface } from '@ethersproject/abi';
+import _ from 'lodash';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for SDai event based
+  system. This is done by fetching the state on-chain before the
+  event block, manually pushing the block logs to the event-subscriber,
+  comparing the local state with on-chain state.
+
+  Most of the logic for testing is abstracted by `testEventSubscriber`.
+  You need to do two things to make the tests work:
+
+  1. Fetch the block numbers where certain events were released. You
+  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
+  block numbers for different events. Make sure to get sufficient
+  number of blockNumbers to cover all possible cases for the event
+  mutations.
+
+  2. Complete the implementation for fetchPoolState function. The
+  function should fetch the on-chain state of the event subscriber
+  using just the blocknumber.
+
+  The template tests only include the test for a single event
+  subscriber. There can be cases where multiple event subscribers
+  exist for a single DEX. In such cases additional tests should be
+  added.
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-events.test.ts`
+
+  (This comment should be removed from the final implementation)
+*/
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'SDai';
+const network = Network.MAINNET;
+
+async function fetchPoolState(
+  sdaiPool: SDaiEventPool,
+  blockNumber: number,
+): Promise<SDaiPoolState> {
+  return sdaiPool.generateState(blockNumber);
+}
+
+describe('SDai Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    drip: [19827559, 19827524, 19827163, 19827124, 19827000, 19826892],
+    // TODO: no matching logs, you have to manually call "file"
+    // from "0xbe8e3e3618f7474f8cb1d074a26affef007e98fb" address
+    // https://etherscan.io/advanced-filter?fadd=0x197e90f9fad81970ba7976f33cbd77088e5d7cf7&tadd=0x197e90f9fad81970ba7976f33cbd77088e5d7cf7&mtd=0x29ae8114%7eFile
+    // file: [19831086]
+  };
+
+  const addresses: { [contract: string]: string } = {
+    potAddress: SDaiConfig[dexKey][network].potAddress,
+  };
+
+  describe('SDaiPool', function () {
+    Object.keys(blockNumbers).forEach((event: string) => {
+      blockNumbers[event].forEach((blockNumber: number) => {
+        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+          const dexHelper = new DummyDexHelper(network);
+          const logger = dexHelper.getLogger(dexKey);
+
+          const sdaiPool = new SDaiEventPool(
+            dexKey,
+            dexHelper,
+            addresses.potAddress,
+            new Interface(PotAbi),
+            logger,
+          );
+
+          await sdaiPool.initialize(blockNumber);
+
+          await testEventSubscriber(
+            sdaiPool,
+            sdaiPool.addressesSubscribed,
+            (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${sdaiPool}`,
+            dexHelper.provider,
+            (state, expected) => {
+              // TODO:
+              expect(_.omit(state, ['chi'])).toEqual(_.omit(expected, ['chi']));
+            },
+          );
+        });
+      });
+    });
+  });
+});