@paraswap/dex-lib 4.1.20 → 4.1.21

package/src/dex/angle-staked-stable/config.ts

@@ -1,139 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap, AdapterMappings } from '../../types';
-import { Network, SwapSide } from '../../constants';
-
-export const AngleStakedStableConfig: DexConfigMap<DexParams> = {
-  // USDA <-> stUSD
-  AngleStakedStableUSD: {
-    [Network.ARBITRUM]: {
-      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
-      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
-    },
-    [Network.MAINNET]: {
-      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
-      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
-    },
-    [Network.OPTIMISM]: {
-      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
-      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
-    },
-    [Network.POLYGON]: {
-      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
-      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
-    },
-    [Network.BASE]: {
-      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
-      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
-    },
-    [Network.BSC]: {
-      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
-      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
-    },
-  },
-  // EURA <-> stEUR
-  AngleStakedStableEUR: {
-    [Network.ARBITRUM]: {
-      agToken: '0xfa5ed56a203466cbbc2430a43c66b9d8723528e7',
-      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
-    },
-    [Network.MAINNET]: {
-      agToken: '0x1a7e4e63778b4f12a199c062f3efdd288afcbce8',
-      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
-    },
-    [Network.OPTIMISM]: {
-      agToken: '0x9485aca5bbbe1667ad97c7fe7c4531a624c8b1ed',
-      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
-    },
-    [Network.POLYGON]: {
-      agToken: '0xe0b52e49357fd4daf2c15e02058dce6bc0057db4',
-      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
-    },
-  },
-};
-
-export const Adapters: Record<number, AdapterMappings> = {
-  [Network.ARBITRUM]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'ArbitrumAdapter03',
-        index: 1,
-      },
-    ],
-    [SwapSide.BUY]: [
-      {
-        name: 'ArbitrumBuyAdapter',
-        index: 10,
-      },
-    ],
-  },
-  [Network.MAINNET]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'Adapter06',
-        index: 1,
-      },
-    ],
-    [SwapSide.BUY]: [
-      {
-        name: 'BuyAdapter02',
-        index: 4,
-      },
-    ],
-  },
-  [Network.OPTIMISM]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'OptimismAdapter02',
-        index: 1,
-      },
-    ],
-    [SwapSide.BUY]: [
-      {
-        name: 'OptimismBuyAdapter',
-        index: 6,
-      },
-    ],
-  },
-  [Network.BASE]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'BaseAdapter01',
-        index: 11,
-      },
-    ],
-    [SwapSide.BUY]: [
-      {
-        name: 'BaseBuyAdapter',
-        index: 7,
-      },
-    ],
-  },
-  [Network.POLYGON]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'PolygonAdapter02',
-        index: 10,
-      },
-    ],
-    [SwapSide.BUY]: [
-      {
-        name: 'PolygonBuyAdapter',
-        index: 9,
-      },
-    ],
-  },
-  [Network.BSC]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'BscAdapter02',
-        index: 10,
-      },
-    ],
-    [SwapSide.BUY]: [
-      {
-        name: 'BscBuyAdapter',
-        index: 8,
-      },
-    ],
-  },
-};

package/src/dex/angle-staked-stable/types.ts

@@ -1,16 +0,0 @@
-import { Address } from '../../types';
-
-export type PoolState = {
-  totalAssets: bigint;
-  totalSupply: bigint;
-  lastUpdate: bigint;
-  rate: bigint;
-  paused: boolean;
-};
-
-export type AngleStakedStableData = { exchange: Address };
-
-export type DexParams = {
-  agToken: Address;
-  stakeToken: Address;
-};

package/src/dex/angle-transmuter/angle-transmuter-e2e.test.ts

@@ -1,156 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { testE2E } from '../../../tests/utils-e2e';
-import {
-  Tokens,
-  Holders,
-  NativeTokenSymbols,
-} from '../../../tests/constants-e2e';
-import { Network, ContractMethod, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-import { generateConfig } from '../../config';
-import { Collateral } from './angle-transmuter-integration.test';
-import { BI_POWS } from '../../bigint-constants';
-import { SmartTokenParams } from '../../../tests/smart-tokens';
-
-function testForNetwork(
-  network: Network,
-  dexKey: string,
-  tokenASymbol: string,
-  tokenBSymbol: string,
-  tokenAAmount: string,
-  tokenBAmount: string,
-  nativeTokenAmount: string,
-  isKYC: boolean,
-) {
-  const provider = new StaticJsonRpcProvider(
-    generateConfig(network).privateHttpProvider,
-    network,
-  );
-  const tokens = Tokens[network];
-  const holders = Holders[network];
-  const nativeTokenSymbol = NativeTokenSymbols[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,
-              );
-            });
-            if (!isKYC) {
-              it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
-                await testE2E(
-                  tokens[tokenBSymbol],
-                  tokens[tokenASymbol],
-                  holders[tokenBSymbol],
-                  side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                );
-              });
-            }
-          });
-        });
-      }),
-    );
-  });
-}
-
-describe('AngleTransmuter E2E', () => {
-  const dexKey = 'AngleTransmuter';
-
-  const networks = [Network.MAINNET, Network.ARBITRUM, Network.BASE];
-  const stablesPerNetwork: { [network: number]: SmartTokenParams[] } = {
-    [Network.MAINNET]: [
-      Tokens[Network.MAINNET].EURA,
-      Tokens[Network.MAINNET].USDA,
-    ],
-    [Network.ARBITRUM]: [Tokens[Network.ARBITRUM].USDA],
-    [Network.BASE]: [Tokens[Network.BASE].USDA],
-  };
-  const collateralsPerNetwork: {
-    [network: number]: { [stable: string]: SmartTokenParams[] };
-  } = {
-    [Network.MAINNET]: {
-      USDA: [
-        Tokens[Network.MAINNET].bIB01,
-        Tokens[Network.MAINNET].USDC,
-        Tokens[Network.MAINNET].steakUSDC,
-      ],
-      EURA: [
-        Tokens[Network.MAINNET].EUROC,
-        Tokens[Network.MAINNET].bC3M,
-        Tokens[Network.MAINNET].bERNX,
-      ],
-    },
-    [Network.ARBITRUM]: {
-      USDA: [Tokens[Network.ARBITRUM].USDC],
-    },
-    [Network.BASE]: {
-      USDA: [Tokens[Network.BASE].USDC],
-    },
-  };
-
-  networks.forEach(network =>
-    describe('Mainnet', () => {
-      const tokens = Tokens[network];
-
-      const stables = stablesPerNetwork[network];
-      const collaterals = collateralsPerNetwork[network];
-
-      const isKYC: { [token: string]: boolean } = {};
-      if (network === Network.MAINNET) {
-        isKYC[tokens.bIB01.symbol!] = true;
-        isKYC[tokens.bC3M.symbol!] = true;
-        isKYC[tokens.bERNX.symbol!] = true;
-      }
-
-      stables.forEach(stable =>
-        collaterals[stable.symbol! as keyof Collateral].forEach(collateral =>
-          describe(`${stable.symbol}/${collateral.symbol}`, () => {
-            const stableAmount: string = (
-              1n * BI_POWS[stable.decimals]
-            ).toString();
-            const collateralAmount: string = (
-              1n * BI_POWS[collateral.decimals]
-            ).toString();
-            const nativeTokenAmount = '1000000000000000000';
-
-            testForNetwork(
-              network,
-              dexKey,
-              collateral.symbol!,
-              stable.symbol!,
-              collateralAmount,
-              stableAmount,
-              nativeTokenAmount,
-              isKYC[collateral.symbol!],
-            );
-          }),
-        ),
-      );
-    }),
-  );
-});

package/src/dex/angle-transmuter/angle-transmuter-events.test.ts

@@ -1,365 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { AngleTransmuterEventPool } from './angle-transmuter-pool';
-import { Network } from '../../constants';
-import { Address } from '../../types';
-import { DummyDexHelper } from '../../dex-helper/index';
-import { testEventSubscriber } from '../../../tests/utils-events';
-import { PoolState } from './types';
-import { DeepReadonly } from 'ts-essentials';
-import {
-  configEUR,
-  configUSD,
-  configUSDArbitrum,
-  configUSDBase,
-} from './constants';
-
-jest.setTimeout(50 * 1000);
-
-async function fetchPoolState(
-  angleTransmuterPools: AngleTransmuterEventPool,
-  blockNumber: number,
-  poolAddress: string,
-): Promise<DeepReadonly<PoolState>> {
-  return angleTransmuterPools.generateState(blockNumber);
-}
-
-// eventName -> blockNumbers
-type EventMappings = Record<string, number[]>;
-
-describe('AngleTransmuter EventPool Mainnet', () => {
-  const dexKey = 'AngleTransmuter';
-  const network = Network.MAINNET;
-  const dexHelper = new DummyDexHelper(network);
-  const logger = dexHelper.getLogger(dexKey);
-  let angleTransmuterPoolEUR: AngleTransmuterEventPool;
-  let angleTransmuterPoolUSD: AngleTransmuterEventPool;
-
-  // poolAddress -> EventMappings
-
-  // EUR
-  const eventsToTestEUR: Record<Address, EventMappings> = {
-    //Transmuter Events
-    '0x00253582b2a3FE112feEC532221d9708c64cEFAb': {
-      FeesSet: [],
-      RedemptionCurveParamsSet: [],
-      OracleSet: [],
-      Swap: [
-        19582703, 19584048, 19589408, 19602964, 19607526, 19614332, 19623965,
-        19625332, 19631246, 19631653, 19633515, 19638468, 19667763,
-      ],
-      Redeemed: [],
-      ReservesAdjusted: [],
-      CollateralAdded: [],
-      CollateralRevoked: [],
-      CollateralWhitelistStatusUpdated: [],
-      WhitelistStatusToggled: [],
-    },
-    // Pyth Events
-    '0x4305FB66699C3B2702D4d05CF36551390A4c69C6': {
-      PriceFeedUpdate: [
-        19611413, 19618548, 19625698, 19632847, 19633586, 19639991, 19647112,
-        19649850, 19649850, 19654237,
-      ],
-    },
-    // Backed Events
-    '0x83Ec02059F686E747392A22ddfED7833bA0d7cE3': {
-      AnswerUpdated: [
-        19574099, 19574442, 19581598, 19588736, 19610148, 19617280, 19624427,
-        19638723, 19667243, 19674385,
-      ],
-    },
-    '0x475855DAe09af1e3f2d380d766b9E630926ad3CE': {
-      AnswerUpdated: [
-        19574095, 19574443, 19581596, 19588737, 19610145, 19617284, 19624426,
-        19631578, 19638720, 19667241, 19674386,
-      ],
-    },
-    //Redstone Events
-    '0x6E27A25999B3C665E44D903B2139F5a4Be2B6C26': {
-      AnswerUpdated: [],
-    },
-  };
-
-  const eventsToTestUSD: Record<Address, EventMappings> = {
-    //Transmuter Events
-    '0x222222fD79264BBE280b4986F6FEfBC3524d0137': {
-      FeesSet: [19539198, 19539199],
-      RedemptionCurveParamsSet: [],
-      OracleSet: [],
-      Swap: [
-        19628073, 19628437, 19629497, 19630262, 19630452, 19630569, 19630846,
-        19630998, 19631045, 19631072, 19631526, 19631561, 19631603, 19631653,
-        19632250, 19633153, 19633531, 19633556, 19633605, 19634664, 19635866,
-        19636522, 19636596, 19637181, 19637803, 19637913, 19638541, 19640895,
-      ],
-      Redeemed: [],
-      ReservesAdjusted: [],
-      CollateralAdded: [],
-      CollateralRevoked: [],
-      CollateralWhitelistStatusUpdated: [],
-      WhitelistStatusToggled: [],
-    },
-    // Chainlink
-    '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6': {
-      AnswerUpdated: [
-        19573923, 19581071, 19588215, 19595354, 19602491, 19609623, 19616758,
-        19623902, 19631050, 19638196, 19645326, 19652441, 19659587, 19666715,
-        19673861, 19681014, 19688159, 19695297, 19702450, 19709605, 19716765,
-      ],
-    },
-    '0x32d1463EB53b73C095625719Afa544D5426354cB': {
-      AnswerUpdated: [
-        19574020, 19581171, 19588315, 19595453, 19602589, 19609722, 19616859,
-        19623999, 19631149, 19638297, 19645426, 19652545, 19652547, 19659686,
-        19666816, 19673959, 19681115, 19688255, 19695398, 19702554, 19709707,
-        19716863,
-      ],
-    },
-    // Morpho
-    '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB': {
-      UpdateLastTotalAssets: [
-        19680251, 19680544, 19681017, 19682815, 19689659, 19689880, 19692533,
-        19697311, 19697903, 19698704, 19698867, 19701099, 19701428, 19702068,
-        19703302, 19703569, 19704999, 19705931, 19705954, 19706402, 19706567,
-        19708213, 19708713, 19708727, 19712712, 19713229, 19714392, 19720091,
-        19720560, 19722127,
-      ],
-      Deposit: [
-        19697903, 19698704, 19698867, 19701099, 19701428, 19702068, 19703302,
-        19703569, 19705931, 19705954, 19706402, 19706567, 19708213, 19708713,
-        19708727, 19713229, 19714392, 19720091, 19720560, 19722127, 19723842,
-        19724873, 19724886, 19727258, 19727832, 19727836, 19727900,
-      ],
-      Withdraw: [
-        19641771, 19642216, 19643013, 19644465, 19646888, 19648977, 19649555,
-        19649742, 19651107, 19651169, 19651577, 19652313, 19662862, 19667407,
-        19669210, 19669302, 19676127, 19680251, 19680544, 19681017, 19682815,
-        19689659, 19704999, 19712712, 19723728,
-      ],
-    },
-  };
-
-  beforeEach(async () => {
-    angleTransmuterPoolEUR = new AngleTransmuterEventPool(
-      `${dexKey}_EUR`,
-      network,
-      dexHelper,
-      logger,
-      configEUR,
-    );
-    angleTransmuterPoolUSD = new AngleTransmuterEventPool(
-      `${dexKey}_USD`,
-      network,
-      dexHelper,
-      logger,
-      configUSD,
-    );
-  });
-
-  Object.entries(eventsToTestEUR).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 () => {
-                  await testEventSubscriber(
-                    angleTransmuterPoolEUR,
-                    angleTransmuterPoolEUR.addressesSubscribed,
-                    (_blockNumber: number) =>
-                      fetchPoolState(
-                        angleTransmuterPoolEUR,
-                        _blockNumber,
-                        poolAddress,
-                      ),
-                    blockNumber,
-                    `${dexKey}_${poolAddress}`,
-                    dexHelper.provider,
-                  );
-                });
-              });
-            });
-          },
-        );
-      });
-    },
-  );
-
-  Object.entries(eventsToTestUSD).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 () => {
-                  await testEventSubscriber(
-                    angleTransmuterPoolUSD,
-                    angleTransmuterPoolUSD.addressesSubscribed,
-                    (_blockNumber: number) =>
-                      fetchPoolState(
-                        angleTransmuterPoolUSD,
-                        _blockNumber,
-                        poolAddress,
-                      ),
-                    blockNumber,
-                    `${dexKey}_${poolAddress}`,
-                    dexHelper.provider,
-                  );
-                });
-              });
-            });
-          },
-        );
-      });
-    },
-  );
-});
-
-describe('AngleTransmuter EventPool - Arbitrum', () => {
-  const dexKey = 'AngleTransmuter';
-  const network = Network.ARBITRUM;
-  const dexHelper = new DummyDexHelper(network);
-  const logger = dexHelper.getLogger(dexKey);
-  let angleTransmuterPoolUSD: AngleTransmuterEventPool;
-
-  // poolAddress -> EventMappings
-
-  const eventsToTestUSD: Record<Address, EventMappings> = {
-    //Transmuter Events
-    '0xD253b62108d1831aEd298Fc2434A5A8e4E418053': {
-      FeesSet: [],
-      RedemptionCurveParamsSet: [],
-      OracleSet: [],
-      Swap: [216524984, 216616166],
-      Redeemed: [],
-      ReservesAdjusted: [],
-      CollateralAdded: [],
-      CollateralRevoked: [],
-      CollateralWhitelistStatusUpdated: [],
-      WhitelistStatusToggled: [],
-      StablecoinCapSet: [],
-    },
-    // Chainlink
-    '0x50834F3163758fcC1Df9973b6e91f0F0F0434aD3': {
-      AnswerUpdated: [
-        216725917, 217070222, 217415479, 217760769, 218104896, 218449091,
-      ],
-    },
-  };
-
-  beforeEach(async () => {
-    angleTransmuterPoolUSD = new AngleTransmuterEventPool(
-      `${dexKey}_USD`,
-      network,
-      dexHelper,
-      logger,
-      configUSDArbitrum,
-    );
-  });
-
-  Object.entries(eventsToTestUSD).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 () => {
-                  await testEventSubscriber(
-                    angleTransmuterPoolUSD,
-                    angleTransmuterPoolUSD.addressesSubscribed,
-                    (_blockNumber: number) =>
-                      fetchPoolState(
-                        angleTransmuterPoolUSD,
-                        _blockNumber,
-                        poolAddress,
-                      ),
-                    blockNumber,
-                    `${dexKey}_${poolAddress}`,
-                    dexHelper.provider,
-                  );
-                });
-              });
-            });
-          },
-        );
-      });
-    },
-  );
-});
-
-describe('AngleTransmuter EventPool - Base', () => {
-  const dexKey = 'AngleTransmuter';
-  const network = Network.BASE;
-  const dexHelper = new DummyDexHelper(network);
-  const logger = dexHelper.getLogger(dexKey);
-  let angleTransmuterPoolUSD: AngleTransmuterEventPool;
-
-  // poolAddress -> EventMappings
-
-  const eventsToTestUSD: Record<Address, EventMappings> = {
-    //Transmuter Events
-    '0x222222880e079445Df703c0604706E71a538Fd4f': {
-      FeesSet: [],
-      RedemptionCurveParamsSet: [],
-      OracleSet: [],
-      Swap: [],
-      Redeemed: [],
-      ReservesAdjusted: [],
-      CollateralAdded: [],
-      CollateralRevoked: [],
-      CollateralWhitelistStatusUpdated: [],
-      WhitelistStatusToggled: [],
-      StablecoinCapSet: [],
-    },
-    // Chainlink
-    '0x7e860098F58bBFC8648a4311b374B1D669a2bc6B': {
-      AnswerUpdated: [15401397],
-    },
-  };
-
-  beforeEach(async () => {
-    angleTransmuterPoolUSD = new AngleTransmuterEventPool(
-      `${dexKey}_USD`,
-      network,
-      dexHelper,
-      logger,
-      configUSDBase,
-    );
-  });
-
-  Object.entries(eventsToTestUSD).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 () => {
-                  await testEventSubscriber(
-                    angleTransmuterPoolUSD,
-                    angleTransmuterPoolUSD.addressesSubscribed,
-                    (_blockNumber: number) =>
-                      fetchPoolState(
-                        angleTransmuterPoolUSD,
-                        _blockNumber,
-                        poolAddress,
-                      ),
-                    blockNumber,
-                    `${dexKey}_${poolAddress}`,
-                    dexHelper.provider,
-                  );
-                });
-              });
-            });
-          },
-        );
-      });
-    },
-  );
-});