@paraswap/dex-lib 3.4.0 → 3.4.1

package/src/dex/platypus/asset.ts

@@ -1,139 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { PartialEventSubscriber } from '../../composed-event-subscriber';
-import {
-  Address,
-  BlockHeader,
-  Log,
-  Logger,
-  MultiCallInput,
-  MultiCallOutput,
-} from '../../types';
-import { Lens } from '../../lens';
-import { Interface } from '@ethersproject/abi';
-import AssetABI from '../../abi/platypus/asset.json';
-import { PlatypusAssetState } from './types';
-
-export class PlatypusAssetSubscriber<State> extends PartialEventSubscriber<
-  State,
-  PlatypusAssetState
-> {
-  static readonly assetInterface = new Interface(AssetABI);
-
-  constructor(
-    private asset: Address,
-    lens: Lens<DeepReadonly<State>, DeepReadonly<PlatypusAssetState>>,
-    logger: Logger,
-  ) {
-    super([asset], lens, logger);
-  }
-
-  public processLog(
-    state: DeepReadonly<PlatypusAssetState>,
-    log: Readonly<Log>,
-    blockHeader: Readonly<BlockHeader>,
-  ): DeepReadonly<PlatypusAssetState> | null {
-    try {
-      const parsed = PlatypusAssetSubscriber.assetInterface.parseLog(log);
-      switch (parsed.name) {
-        case 'CashAdded': {
-          const previousCashPosition = BigInt(
-            parsed.args.previousCashPosition.toString(),
-          );
-          const cashBeingAdded = BigInt(parsed.args.cashBeingAdded.toString());
-          if (state.cash !== previousCashPosition) {
-            this.logger.error('state.cash !== previousCashPosition');
-          }
-          return {
-            cash: previousCashPosition + cashBeingAdded,
-            liability: state.liability,
-          };
-        }
-        case 'CashRemoved': {
-          const previousCashPosition = BigInt(
-            parsed.args.previousCashPosition.toString(),
-          );
-          const cashBeingRemoved = BigInt(
-            parsed.args.cashBeingRemoved.toString(),
-          );
-          if (state.cash !== previousCashPosition) {
-            this.logger.error('state.cash !== previousCashPosition');
-          }
-          return {
-            cash: previousCashPosition - cashBeingRemoved,
-            liability: state.liability,
-          };
-        }
-        case 'LiabilityAdded': {
-          const previousLiabilityPosition = BigInt(
-            parsed.args.previousLiabilityPosition.toString(),
-          );
-          const liabilityBeingAdded = BigInt(
-            parsed.args.liabilityBeingAdded.toString(),
-          );
-          if (state.liability !== previousLiabilityPosition) {
-            this.logger.error('state.liability !== previousLiabilityPosition');
-          }
-          return {
-            cash: state.cash,
-            liability: previousLiabilityPosition + liabilityBeingAdded,
-          };
-        }
-        case 'LiabilityRemoved': {
-          const previousLiabilityPosition = BigInt(
-            parsed.args.previousLiabilityPosition.toString(),
-          );
-          const liabilityBeingRemoved = BigInt(
-            parsed.args.liabilityBeingRemoved.toString(),
-          );
-          if (state.liability !== previousLiabilityPosition) {
-            this.logger.error('state.liability !== previousLiabilityPosition');
-          }
-          return {
-            cash: state.cash,
-            liability: previousLiabilityPosition - liabilityBeingRemoved,
-          };
-        }
-        default:
-          return null;
-      }
-    } catch (e) {
-      this.logger.error('Failed to parse log', e);
-      return null;
-    }
-  }
-
-  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
-    return [
-      {
-        target: this.asset,
-        callData:
-          PlatypusAssetSubscriber.assetInterface.encodeFunctionData('cash'),
-      },
-      {
-        target: this.asset,
-        callData:
-          PlatypusAssetSubscriber.assetInterface.encodeFunctionData(
-            'liability',
-          ),
-      },
-    ];
-  }
-
-  public generateState(
-    multicallOutputs: MultiCallOutput[],
-    blockNumber?: number | 'latest',
-  ): DeepReadonly<PlatypusAssetState> {
-    return {
-      cash: BigInt(
-        PlatypusAssetSubscriber.assetInterface
-          .decodeFunctionResult('cash', multicallOutputs[0])[0]
-          .toString(),
-      ),
-      liability: BigInt(
-        PlatypusAssetSubscriber.assetInterface
-          .decodeFunctionResult('liability', multicallOutputs[1])[0]
-          .toString(),
-      ),
-    };
-  }
-}

package/src/dex/platypus/config.ts

@@ -1,72 +0,0 @@
-import { DexParams, PlatypusOracleType } from './types';
-import { DexConfigMap } from '../../types';
-import { Network, SwapSide } from '../../constants';
-
-export const PlatypusConfig: DexConfigMap<DexParams> = {
-  Platypus: {
-    [Network.AVALANCHE]: {
-      pools: [
-        {
-          address: '0xbe52548488992Cc76fFA1B42f3A58F646864df45',
-          name: 'Main USD Pool',
-          oracleType: PlatypusOracleType.ChainLink,
-        },
-        {
-          address: '0xB8E567fc23c39C94a1f6359509D7b43D1Fbed824',
-          name: 'Alt Pool Frax',
-          oracleType: PlatypusOracleType.ChainLink,
-        },
-        {
-          address: '0x30C30d826be87Cd0A4b90855C2F38f7FcfE4eaA7',
-          name: 'Alt Pool MIM',
-          oracleType: PlatypusOracleType.ChainLink,
-        },
-        {
-          address: '0x39dE4e02F76Dbd4352Ec2c926D8d64Db8aBdf5b2',
-          name: 'Alt Pool BTC',
-          oracleType: PlatypusOracleType.None,
-        },
-        {
-          address: '0x4658EA7e9960D6158a261104aAA160cC953bb6ba',
-          name: 'Alt Pool sAVAX',
-          oracleType: PlatypusOracleType.StakedAvax,
-        },
-        {
-          address: '0xC828D995C686AaBA78A4aC89dfc8eC0Ff4C5be83',
-          name: 'Alt Pool YUSD',
-          oracleType: PlatypusOracleType.None,
-        },
-        {
-          address: '0x233Ba46B01d2FbF1A31bDBc500702E286d6de218',
-          name: 'Factory Pool H2O',
-          oracleType: PlatypusOracleType.None,
-        },
-        {
-          address: '0x27912AE6Ba9a54219d8287C3540A8969FF35500B',
-          name: 'Factory Pool MONEY',
-          oracleType: PlatypusOracleType.None,
-        },
-        {
-          address: '0x91BB10D68C72d64a7cE10482b453153eEa03322C',
-          name: 'Factory Pool TSD',
-          oracleType: PlatypusOracleType.None,
-        },
-      ],
-    },
-  },
-};
-
-export const Adapters: {
-  [chainId: number]: {
-    [side: string]: { name: string; index: number }[] | null;
-  };
-} = {
-  [Network.AVALANCHE]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'AvalancheAdapter01',
-        index: 10,
-      },
-    ],
-  },
-};

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

@@ -1,168 +0,0 @@
-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';
-
-describe('Platypus E2E', () => {
-  const dexKey = 'Platypus';
-
-  describe('Platypus AVALANCHE_V6', () => {
-    const network = Network.AVALANCHE;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-
-    const tokenASymbol: string = 'USDC';
-    const tokenBSymbol: string = 'DAIE';
-
-    const tokenAAmount: string = '9999000000';
-    const tokenBAmount: string = '9999000000000000000000';
-
-    const sideToContractMethods = new Map([
-      [
-        SwapSide.SELL,
-        [
-          ContractMethod.swapExactAmountIn,
-          // ContractMethod.simpleSwap,
-          // ContractMethod.multiSwap,
-          // ContractMethod.megaSwap,
-        ],
-      ],
-    ]);
-
-    const poolTokenSymbols: string[] = [
-      'newFRAX',
-      'MIM',
-      'YUSD',
-      // 'H2O', // pool is paused
-      'MONEY',
-      'TSD',
-    ];
-
-    sideToContractMethods.forEach((contractMethods, 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,
-            );
-          });
-          it(`AVAX -> sAVAX`, async () => {
-            await testE2E(
-              tokens['AVAX'],
-              tokens['sAVAX'],
-              holders['AVAX'],
-              '999000000000000000000',
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it(`WAVAX -> sAVAX`, async () => {
-            await testE2E(
-              tokens['WAVAX'],
-              tokens['sAVAX'],
-              holders['WAVAX'],
-              '999000000000000000000',
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it(`sAVAX -> AVAX`, async () => {
-            await testE2E(
-              tokens['sAVAX'],
-              tokens['AVAX'],
-              holders['sAVAX'],
-              '999000000000000000000',
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it(`sAVAX -> WAVAX`, async () => {
-            await testE2E(
-              tokens['sAVAX'],
-              tokens['WAVAX'],
-              holders['sAVAX'],
-              '999000000000000000000',
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          if (
-            contractMethod === ContractMethod.simpleSwap &&
-            side === SwapSide.SELL
-          ) {
-            poolTokenSymbols.forEach(poolTokenSymbol => {
-              it(`${tokenASymbol} -> ${poolTokenSymbol}`, async () => {
-                await testE2E(
-                  tokens[tokenASymbol],
-                  tokens[poolTokenSymbol],
-                  holders[tokenASymbol],
-                  tokenAAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                );
-              });
-            });
-          }
-        });
-      }),
-    );
-
-    it(`wBTC -> BTCb`, async () => {
-      await testE2E(
-        tokens['wBTC'],
-        tokens['BTCb'],
-        holders['wBTC'],
-        '300000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.simpleSwap,
-        network,
-        provider,
-      );
-    });
-  });
-});

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

@@ -1,167 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { Platypus } from './platypus';
-import { PlatypusPoolBase } from './pool-base';
-import { PlatypusPool } from './pool';
-import { PlatypusAvaxPool } from './pool-avax';
-import { PlatypusConfig } from './config';
-import { Network } from '../../constants';
-import { DummyDexHelper } from '../../dex-helper/index';
-import {
-  testEventSubscriber,
-  getSavedConfig,
-  saveConfig,
-} from '../../../tests/utils-events';
-import {
-  PlatypusOracleType,
-  PlatypusConfigInfo,
-  PlatypusPoolStateCommon,
-} from './types';
-
-jest.setTimeout(50 * 1000);
-const dexKey = 'Platypus';
-const network = Network.AVALANCHE;
-const config = PlatypusConfig[dexKey][network];
-const poolIndex = 0;
-
-async function fetchPoolState<T extends PlatypusPoolStateCommon>(
-  platypusPool: PlatypusPoolBase<T>,
-  blockNumber: number,
-) {
-  return await platypusPool.generateState(blockNumber);
-}
-
-describe('Platypus Event', function () {
-  /*
-  CashAdded [
-    13967197, 13967347,
-    13968151, 13968200,
-    13968422, 13968513,
-    13968690, 13968780,
-    13968791, 13968951,
-    13969056
-  ]
-  CashRemoved [
-    13967310, 13967398,
-    13967401, 13967705,
-    13967832, 13967867,
-    13968025, 13968138,
-    13968467, 13968489,
-    13968604, 13968978,
-    13969060
-  ]
-  LiabilityAdded [ 13967398, 13967401, 13967705, 13967832, 13967867, 13968025 ]
-  LiabilityRemoved [
-    13967310, 13968138,
-    13968467, 13968489,
-    13968604, 13968978,
-    13969060
-  ]
-  AnswerUpdated [ 13941238 ]
-  HaircutRateUpdated [ 10134648 ]
-  */
-  const blockNumbers: { [eventName: string]: number[] } = {
-    CashAdded: [13967197],
-    CashRemoved: [13967398],
-    LiabilityAdded: [13967401],
-    LiabilityRemoved: [13967310],
-    AnswerUpdated: [13941238],
-    HaircutRateUpdated: [10134648],
-  };
-
-  describe('PlatypusPool', 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);
-
-          let cfgInfo = getSavedConfig<PlatypusConfigInfo>(blockNumber, dexKey);
-          if (!cfgInfo) {
-            const dex = new Platypus(network, dexKey, dexHelper);
-            cfgInfo = await dex.generateConfigInfo(blockNumber);
-            saveConfig(blockNumber, dexKey, cfgInfo);
-          }
-
-          const cfgInfoPool =
-            cfgInfo.pools[config.pools[poolIndex].address.toLowerCase()];
-          if (cfgInfoPool.oracleType !== PlatypusOracleType.ChainLink) {
-            throw new Error('Wrong Platypus oracle type for this test!');
-          }
-          const platypusPool = new PlatypusPool(
-            dexKey,
-            network,
-            config.pools[poolIndex].name,
-            config.pools[poolIndex].address,
-            cfgInfoPool,
-            dexHelper,
-          );
-
-          await testEventSubscriber(
-            platypusPool,
-            platypusPool.addressesSubscribed,
-            (_blockNumber: number) =>
-              fetchPoolState(platypusPool, _blockNumber),
-            blockNumber,
-            `${dexKey}_${config.pools[poolIndex].address}`,
-            dexHelper.provider,
-          );
-        });
-      });
-    });
-  });
-
-  /*
-  Submitted [ 16399520, 16401225 ]
-  Redeem [ 16402280, 16402429 ]
-  AccrueRewards [ 16401653, 16403057 ]
-  */
-  const blockNumbersAvax: { [eventName: string]: number[] } = {
-    Submitted: [16399520, 16401225],
-    Redeem: [16402280, 16402429],
-    AccrueRewards: [16401653, 16403057],
-  };
-
-  const poolIndexAvax = 4;
-
-  describe('PlatypusAvaxPool', function () {
-    Object.keys(blockNumbersAvax).forEach((event: string) => {
-      blockNumbersAvax[event].forEach((blockNumber: number) => {
-        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
-          const dexHelper = new DummyDexHelper(network);
-
-          let cfgInfo = getSavedConfig<PlatypusConfigInfo>(blockNumber, dexKey);
-          if (!cfgInfo) {
-            const dex = new Platypus(network, dexKey, dexHelper);
-            cfgInfo = await dex.generateConfigInfo(blockNumber);
-            saveConfig(blockNumber, dexKey, cfgInfo);
-          }
-
-          const cfgInfoPool =
-            cfgInfo.pools[config.pools[poolIndexAvax].address.toLowerCase()];
-          if (cfgInfoPool.oracleType !== PlatypusOracleType.StakedAvax) {
-            throw new Error('Wrong Platypus oracle type for this test!');
-          }
-          const platypusPool = new PlatypusAvaxPool(
-            dexKey,
-            network,
-            config.pools[poolIndexAvax].name,
-            config.pools[poolIndexAvax].address,
-            cfgInfoPool,
-            dexHelper,
-          );
-
-          await testEventSubscriber(
-            platypusPool,
-            platypusPool.addressesSubscribed,
-            (_blockNumber: number) =>
-              fetchPoolState(platypusPool, _blockNumber),
-            blockNumber,
-            `${dexKey}_${config.pools[poolIndexAvax].address}`,
-            dexHelper.provider,
-          );
-        });
-      });
-    });
-  });
-});