@paraswap/dex-lib 2.50.8 → 2.50.9

package/src/config.ts

@@ -170,8 +170,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_56`]?.split(',') || [],
     adapterAddresses: {
       BscAdapter01: '0xA31d9C571DF00e0F428B0bD24c34D103E8112222',
-      BscAdapter02: '0x9A92D2649C38415860FA59ba8B9a9960cd2839Db',
-      BscBuyAdapter: '0xd32C191e0febaa6Cc93A29Cb676474c72486E00b',
+      BscAdapter02: '0x7A8f0436981B893349514655a00Ca974A6e9fd93',
+      BscBuyAdapter: '0x2389726B55948d8D8944b0145204761215AaEc71',
     },
     rpcPollingMaxAllowedStateDelayInBlocks: 1,
     rpcPollingBlocksBackToTriggerUpdate: 1,
@@ -199,8 +199,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_137`]?.split(',') || [],
     adapterAddresses: {
       PolygonAdapter01: '0xE44769f42E1e9592f86B82f206407a8f7C84b4ed',
-      PolygonAdapter02: '0x84bEF12C9931cE12662cc9F2366b6a5029E4BD29',
-      PolygonBuyAdapter: '0xBAEeb4540f59d30E567a5B563CC0c4587eDd9366',
+      PolygonAdapter02: '0xE7d4CC1589311BD7Bb58739269748a20DAAD755D',
+      PolygonBuyAdapter: '0x8643Aa3E63dF7742223A713C7525677df336183f',
     },
     uniswapV2ExchangeRouterAddress:
       '0xf3938337F7294fEf84e9B2c6D548A93F956Cc281',
@@ -323,7 +323,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_10`]?.split(',') || [],
     adapterAddresses: {
       OptimismAdapter01: '0x5dcf544b0c9689fa67dcb713fd2656d217e25a59',
-      OptimismBuyAdapter: '0xA10c9a84E72d9DfF424Fe2284B6460784bed407E',
+      OptimismAdapter02: '0x4483Ae378897eB9FbF7f15Df98Bf07233ffFEe8b',
+      OptimismBuyAdapter: '0xe9166234DFB6d3ec05C82404109C02Ca82b16c22',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',
@@ -380,8 +381,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     smardexSubgraphAuthToken: process.env.API_KEY_SMARDEX_SUBGRAPH || '',
     hashFlowDisabledMMs: [],
     adapterAddresses: {
-      BaseAdapter01: '0xf531fC01aFa26dAa71f581e1e18AA3B37Ee515A6',
-      BaseBuyAdapter: '0x2B99cefbfeE6f134D68aBB291386588ADe3808F8',
+      BaseAdapter01: '0xe53d24CD81cC81bbf271AD7B02D0d67f851D727c',
+      BaseBuyAdapter: '0xe07678E5Fd104cbabb239049148b8a4E9dA5d07E',
     },
     uniswapV2ExchangeRouterAddress:
       '0x75d199EfB540e47D27D52c62Da3E7daC2B9e834F',

package/src/dex/angle-staked-stable/angle-staked-stable-e2e.test.ts

@@ -0,0 +1,146 @@
+/* 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';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+) {
+  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.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,
+                undefined,
+                undefined,
+                undefined,
+                1,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                1,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('AngleStakedStable E2E', () => {
+  const networksEUR = [
+    Network.MAINNET,
+    Network.ARBITRUM,
+    Network.POLYGON,
+    Network.OPTIMISM,
+  ];
+
+  const networksUSD = [
+    Network.MAINNET,
+    Network.ARBITRUM,
+    Network.POLYGON,
+    Network.OPTIMISM,
+    Network.BASE,
+    Network.BSC,
+  ];
+
+  networksEUR.forEach(network =>
+    describe(`${network} - EUR`, () => {
+      const dexKey = 'AngleStakedStableEUR';
+      const tokenASymbol: string = 'EURA';
+      const tokenBSymbol: string = 'stEUR';
+      const tokenAAmount: string = '990000000000000000';
+      const tokenBAmount: string = '990000000000000000';
+      const nativeTokenAmount = '990000000000000000';
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    }),
+  );
+
+  networksUSD.forEach(network =>
+    describe(`${network} - USD`, () => {
+      const dexKey = 'AngleStakedStableUSD';
+      const tokenASymbol: string = 'USDA';
+      const tokenBSymbol: string = 'stUSD';
+      const tokenAAmount: string = '990000000000000000';
+      const tokenBAmount: string = '990000000000000000';
+      const nativeTokenAmount = '990000000000000000';
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    }),
+  );
+});

package/src/dex/angle-staked-stable/angle-staked-stable-events.test.ts

@@ -0,0 +1,95 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { AngleStakedStableEventPool } from './angle-staked-stable-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 { AngleStakedStableConfig } from './config';
+
+jest.setTimeout(50 * 1000);
+
+async function fetchPoolState(
+  angleStakedStablePools: AngleStakedStableEventPool,
+  blockNumber: number,
+  poolAddress: string,
+): Promise<PoolState> {
+  return angleStakedStablePools.generateState(blockNumber);
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+describe('AngleStakedStable EventPool Mainnet', () => {
+  const dexKey = 'AngleStakedStableEUR';
+  const network = Network.MAINNET;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  let angleStakedStablePool: AngleStakedStableEventPool;
+
+  // poolAddress -> EventMappings
+  const eventsToTest: Record<Address, EventMappings> = {
+    '0x004626a008b1acdc4c74ab51644093b155e59a23': {
+      Accrued: [
+        19368181, 19387091, 19387136, 19390671, 19395050, 19395068, 19404404,
+        19404492, 19407830, 19410813, 19482839, 19575712, 19622932, 19622960,
+        19632489, 19650535, 19668024, 19668335, 19669259, 19672358, 19675559,
+        19679409,
+      ],
+      Deposit: [
+        19387091, 19387136, 19395050, 19404404, 19410813, 19622932, 19622960,
+        19632489, 19668335, 19669259, 19672358, 19675559,
+      ],
+      Withdraw: [
+        19368181, 19390671, 19395068, 19404492, 19407830, 19482839, 19575712,
+        19650535, 19679409,
+      ],
+      ToggledPause: [],
+      RateUpdated: [19668024],
+    },
+  };
+
+  beforeEach(async () => {
+    angleStakedStablePool = new AngleStakedStableEventPool(
+      dexKey,
+      network,
+      dexHelper,
+      AngleStakedStableConfig[dexKey][network].stakeToken,
+      AngleStakedStableConfig[dexKey][network].agToken,
+      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 () => {
+                  await testEventSubscriber(
+                    angleStakedStablePool,
+                    angleStakedStablePool.addressesSubscribed,
+                    (_blockNumber: number) =>
+                      fetchPoolState(
+                        angleStakedStablePool,
+                        _blockNumber,
+                        poolAddress,
+                      ),
+                    blockNumber,
+                    `${dexKey}_${poolAddress}`,
+                    dexHelper.provider,
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+});