@paraswap/dex-lib 3.4.0 → 3.4.1

package/src/dex/swaap-v1/types.ts

@@ -1,124 +0,0 @@
-import { Address } from '../../types';
-import { ChainLinkState } from '../../lib/chainlink';
-import { BigNumber } from '@0x/utils';
-
-export type SwaapV1PoolState = {
-  parameters: SwaapV1PoolParameters;
-  liquidities: SwaapV1PoolLiquidities;
-  oracles: SwaapV1PoolOracles;
-};
-
-export type SwaapV1PoolLiquidities = {
-  [tokenAddress: Address]: TokenData;
-};
-
-export type SwaapV1PoolOracles = {
-  [tokenAddress: Address]: OracleData;
-};
-
-export type SwaapV1PoolParameters = {
-  swapFee: bigint;
-  priceStatisticsLookbackInRound: number;
-  priceStatisticsLookbackStepInRound: number;
-  dynamicCoverageFeesZ: bigint;
-  dynamicCoverageFeesHorizon: bigint;
-  priceStatisticsLookbackInSec: bigint;
-  maxPriceUnpegRatio: bigint;
-};
-
-export type TokenData = {
-  balance: bigint;
-  initialWeight: bigint;
-  decimals: number;
-};
-
-export type OracleData = {
-  oraclesBindState: OracleInitialData;
-  latestRoundId: number;
-  historicalOracleState: ChainLinkData;
-};
-
-// Oracle state when a token is binded/rebinded
-export type OracleInitialData = {
-  proxy: Address;
-  aggregator: Address;
-  price: bigint;
-  decimals: number;
-  description: string;
-};
-
-export type ChainLinkData = { [latestRoundId: number]: ChainLinkState };
-
-export type DexParams = {
-  subgraphURL: string;
-  exchangeProxy: string;
-};
-
-export type SubgraphToken = {
-  address: string;
-  decimals: number;
-  oracleInitialState: OracleInitialData;
-  latestRoundId: number;
-  oracleHistoricalStates: ChainLinkData;
-};
-
-export type TokenState = {
-  balance: bigint;
-  weight?: bigint;
-};
-
-export enum SwapTypes {
-  SwapExactIn,
-  SwapExactOut,
-}
-
-export interface callData {
-  target: string;
-  callData: string;
-}
-
-export type SwaapV1AssetState = {
-  cash: bigint;
-  liability: bigint;
-};
-
-export type SwaapV1Data = {
-  pool: Address;
-};
-
-export interface SubgraphPoolBase {
-  id: string;
-  tokens: SubgraphToken[];
-  liquidityUSD: number;
-  swapFee: number;
-  priceStatisticsLookbackInRound: number;
-  priceStatisticsLookbackStepInRound: number;
-  dynamicCoverageFeesZ: number;
-  dynamicCoverageFeesHorizon: number;
-  priceStatisticsLookbackInSec: number;
-  maxPriceUnpegRatio: number;
-}
-export type SwaapV1Swap = {
-  pool: Address;
-  tokenIn: Address;
-  tokenOut: Address;
-  swapAmount: bigint;
-  limitAmount: bigint;
-  maxPrice: bigint;
-};
-
-export type SwaapV1ProxySwapArguments = [
-  swaps: SwaapV1Swap[],
-  tokenIn: Address,
-  tokenOut: Address,
-  lmimitAmount: bigint,
-  deadline: bigint,
-];
-
-export type SwaapV1PoolSwapArguments = [
-  tokenIn: Address,
-  amountIn: bigint,
-  tokenOut: Address,
-  amountOut: bigint,
-  maxPrice: bigint,
-];

package/src/dex/uniswap-v2/uniswap-v2-e2e-ropsten.test.ts

@@ -1,481 +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('UniswapV2 E2E Ropsten', () => {
-  const dexKey = 'UniswapV2';
-  const network = Network.ROPSTEN;
-  const tokens = Tokens[network];
-  const holders = Holders[network];
-  const provider = new StaticJsonRpcProvider(
-    generateConfig(network).privateHttpProvider,
-    network,
-  );
-
-  describe('SimpleSwap', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.simpleSwap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '400000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.simpleSwap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.simpleSwap,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('MultiSwap', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.multiSwap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '400000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.multiSwap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.multiSwap,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('MegaSwap', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.megaSwap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '400000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.megaSwap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.megaSwap,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('SimpleBuy', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.simpleBuy,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '1000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.simpleBuy,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.simpleBuy,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('BuyMethod', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buy,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '1000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buy,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buy,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('DirectSwapOnUniswap', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '400000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswap,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('DirectSwapOnUniswapFork', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswapFork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '400000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswapFork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswapFork,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('DirectBuyOnUniswap', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '1000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswap,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswap,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('DirectBuyOnUniswapFork', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswapFork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '1000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswapFork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswapFork,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('DirectSwapOnUniswapV2Fork', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswapV2Fork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '400000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswapV2Fork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.swapOnUniswapV2Fork,
-        network,
-        provider,
-      );
-    });
-  });
-
-  describe('DirectBuyOnUniswapV2Fork', () => {
-    it('ETH -> TOKEN', async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.DAI,
-        holders.ETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswapV2Fork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> ETH', async () => {
-      await testE2E(
-        tokens.DAI,
-        tokens.ETH,
-        holders.DAI,
-        '1000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswapV2Fork,
-        network,
-        provider,
-      );
-    });
-    it('TOKEN -> TOKEN', async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.DAI,
-        holders.WETH,
-        '400000000000000000000',
-        SwapSide.BUY,
-        dexKey,
-        ContractMethod.buyOnUniswapV2Fork,
-        network,
-        provider,
-      );
-    });
-  });
-});