@paraswap/dex-lib 4.1.19 → 4.1.20-aave-gsm-u

package/tests/utils-events.ts

@@ -1,186 +0,0 @@
-import _ from 'lodash';
-import fs from 'fs';
-import path from 'path';
-import { Log, BlockHeader, Address } from '../src/types';
-import { StatefulEventSubscriber } from '../src/stateful-event-subscriber';
-import { Provider } from '@ethersproject/providers';
-import { DeepReadonly } from 'ts-essentials';
-
-const configPath = './configs.json';
-const absConfigPath = path.join(__dirname, configPath);
-let configs: { [k: string]: any } = {};
-if (fs.existsSync(absConfigPath)) configs = require(configPath);
-
-const statePath = './states.json';
-const absStatePath = path.join(__dirname, statePath);
-let states: { [k: string]: any } = {};
-if (fs.existsSync(absStatePath)) states = require(statePath);
-
-const logPath = './logs.json';
-const absLogPath = path.join(__dirname, logPath);
-let logs: { [k: string]: BlockInfo } = {};
-if (fs.existsSync(absLogPath)) logs = require(logPath);
-
-const bigintify = (val: string) => BigInt(val);
-const stringify = (val: bigint) => val.toString();
-
-interface BlockInfo {
-  logs: Log[];
-  blockHeaders: { [blockNumber: number]: BlockHeader };
-}
-
-export async function testEventSubscriber<SubscriberState>(
-  eventSubscriber: StatefulEventSubscriber<SubscriberState>,
-  subscribedAddress: Address[],
-  fetchState: (blocknumber: number) => Promise<SubscriberState>,
-  blockNumber: number,
-  cacheKey: string,
-  provider: Provider,
-  stateCompare?: (
-    state: SubscriberState,
-    expectedState: SubscriberState,
-  ) => void,
-) {
-  // Get state of the subscriber block before the event was released
-  let poolState = getSavedState(blockNumber - 1, cacheKey);
-  if (!poolState) {
-    poolState = await fetchState(blockNumber - 1);
-    saveState(blockNumber - 1, cacheKey, poolState);
-  }
-
-  // Set subscriber state before the event block
-  eventSubscriber.setState(
-    poolState as DeepReadonly<SubscriberState>,
-    blockNumber - 1,
-  );
-  eventSubscriber.isTracking = () => true;
-
-  // Get logs and blockHeader of the block when the event was emitted
-  let blockInfo = await getSavedBlockInfo(blockNumber, cacheKey);
-  if (!blockInfo) {
-    const logs = (
-      await Promise.all(
-        subscribedAddress.map(address =>
-          provider.getLogs({
-            fromBlock: blockNumber,
-            toBlock: blockNumber,
-            address,
-          }),
-        ),
-      )
-    )
-      .flat()
-      .sort((a, b) => a.logIndex - b.logIndex);
-
-    blockInfo = {
-      logs,
-      blockHeaders: {
-        [blockNumber]: <BlockHeader>(
-          (<unknown>await provider.getBlock(blockNumber))
-        ),
-      },
-    };
-    saveBlockInfo(blockNumber, cacheKey, blockInfo);
-  }
-
-  // Update subscriber with event logs
-  await eventSubscriber.update(blockInfo.logs, blockInfo.blockHeaders);
-
-  // Get the expected state of the subscriber after the event
-  let expectedNewPoolState = getSavedState(blockNumber, cacheKey);
-  if (!expectedNewPoolState) {
-    expectedNewPoolState = await fetchState(blockNumber);
-    saveState(blockNumber, cacheKey, expectedNewPoolState);
-  }
-
-  // Get the updated state of the subscriber
-  const newPoolState = eventSubscriber.getState(blockNumber);
-
-  // Expect the updated state to be same as the expected state
-  if (stateCompare) {
-    expect(newPoolState).not.toBeNull();
-    stateCompare(
-      newPoolState as SubscriberState,
-      expectedNewPoolState as SubscriberState,
-    );
-  } else {
-    expect(newPoolState).toEqual(expectedNewPoolState);
-  }
-}
-
-export function deepTypecast<T>(
-  obj: any,
-  checker: (val: any) => boolean,
-  caster: (val: T) => any,
-): any {
-  return _.forEach(obj, (val: any, key: any, obj: any) => {
-    obj[key] = checker(val)
-      ? caster(val)
-      : _.isObject(val)
-      ? deepTypecast(val, checker, caster)
-      : val;
-  });
-}
-
-export function getSavedConfig<Config>(
-  blockNumber: number,
-  cacheKey: string,
-): Config | undefined {
-  const _config = configs[`${cacheKey}_${blockNumber}`];
-  if (_config) {
-    const checker = (obj: any) => _.isString(obj) && obj.includes('bi@');
-    const caster = (obj: string) => bigintify(obj.slice(3));
-    return deepTypecast<string>(_.cloneDeep(_config), checker, caster);
-  }
-  return undefined;
-}
-
-export function saveConfig<Config>(
-  blockNumber: number,
-  cacheKey: string,
-  config: Config,
-) {
-  const checker = (obj: any) => typeof obj === 'bigint';
-  const caster = (obj: bigint) => 'bi@'.concat(stringify(obj));
-  const _config = deepTypecast<bigint>(_.cloneDeep(config), checker, caster);
-  configs[`${cacheKey}_${blockNumber}`] = _config;
-  fs.writeFileSync(absConfigPath, JSON.stringify(configs, null, 2));
-}
-
-export function getSavedState<SubscriberState>(
-  blockNumber: number,
-  cacheKey: string,
-): SubscriberState | undefined {
-  const _state = states[`${cacheKey}_${blockNumber}`];
-  if (_state) {
-    const checker = (obj: any) => _.isString(obj) && obj.includes('bi@');
-    const caster = (obj: string) => bigintify(obj.slice(3));
-    return deepTypecast<string>(_.cloneDeep(_state), checker, caster);
-  }
-  return undefined;
-}
-
-function saveState<SubscriberState>(
-  blockNumber: number,
-  cacheKey: string,
-  state: SubscriberState,
-) {
-  const checker = (obj: any) => typeof obj === 'bigint';
-  const caster = (obj: bigint) => 'bi@'.concat(stringify(obj));
-  const _state = deepTypecast<bigint>(_.cloneDeep(state), checker, caster);
-  states[`${cacheKey}_${blockNumber}`] = _state;
-  fs.writeFileSync(absStatePath, JSON.stringify(states, null, 2));
-}
-
-function getSavedBlockInfo(blockNumber: number, cacheKey: string): BlockInfo {
-  return logs[`${cacheKey}_${blockNumber}`];
-}
-
-function saveBlockInfo(
-  blockNumber: number,
-  cacheKey: string,
-  blockInfo: BlockInfo,
-) {
-  logs[`${cacheKey}_${blockNumber}`] = blockInfo;
-  fs.writeFileSync(absLogPath, JSON.stringify(logs, null, 2));
-}

package/tests/utils.ts

@@ -1,127 +0,0 @@
-/* eslint-disable no-console */
-import { ethers } from 'ethers';
-import { PoolPrices, PoolLiquidity, Address } from '../src/types';
-import { SwapSide } from '../src/constants';
-import { assert } from 'ts-essentials';
-
-// Assuming that the amounts are increasing at same interval, and start with 0
-export function checkPoolPrices(
-  poolPrices: PoolPrices<any>[],
-  amounts: bigint[],
-  side: SwapSide,
-  dexKey: string,
-  expectIncreasingValues: boolean = true,
-) {
-  for (const poolPrice of poolPrices) {
-    expect(poolPrice.prices.length).toBe(amounts.length);
-    expect(poolPrice.prices[0]).toEqual(0n);
-
-    poolPrice.prices.forEach(p => expect(p).toBeGreaterThanOrEqual(0));
-    expect(poolPrice.unit).toBeGreaterThanOrEqual(0);
-
-    if (expectIncreasingValues) {
-      for (let i = 2; i < poolPrice.prices.length; ++i) {
-        const prevMarginalPrice =
-          poolPrice.prices[i - 1] - poolPrice.prices[i - 2];
-        const currMarginalPrice = poolPrice.prices[i] - poolPrice.prices[i - 1];
-
-        //This check has 1% fudge factor to avoid slight differences causing error
-        if (side === SwapSide.SELL)
-          expect((currMarginalPrice * 99n) / 100n).toBeLessThanOrEqual(
-            prevMarginalPrice,
-          );
-        else
-          expect((currMarginalPrice * 101n) / 100n).toBeGreaterThan(
-            prevMarginalPrice,
-          );
-      }
-    }
-
-    expect(poolPrice.exchange).toEqual(dexKey);
-  }
-}
-
-export function checkConstantPoolPrices(
-  poolPrices: PoolPrices<any>[],
-  amounts: bigint[],
-  dexKey: string,
-) {
-  for (const poolPrice of poolPrices) {
-    expect(poolPrice.exchange).toEqual(dexKey);
-    expect(poolPrice.prices.length).toEqual(amounts.length);
-    for (let i = 0; i < poolPrice.prices.length; ++i) {
-      expect(poolPrice.prices[i]).toEqual(amounts[i]);
-    }
-  }
-}
-
-export function checkPoolsLiquidity(
-  poolsLiquidity: PoolLiquidity[],
-  tokenAddress: Address,
-  dexKey: string,
-) {
-  expect(poolsLiquidity.length).toBeGreaterThan(0);
-
-  poolsLiquidity.forEach(p => {
-    expect(p.exchange).toEqual(dexKey);
-    expect(p.liquidityUSD).toBeGreaterThanOrEqual(0);
-    p.connectorTokens.forEach(t => {
-      expect(t.address).not.toBe(tokenAddress);
-      expect(t.decimals).toBeGreaterThanOrEqual(0);
-    });
-  });
-}
-
-export const sleep = (time: number) =>
-  new Promise(resolve => {
-    setTimeout(resolve, time);
-  });
-
-export const generateDeployBytecode = (
-  testContractProjectRootPath: string | undefined,
-  testContractName: string | undefined,
-  testContractConfigFileName: string | undefined,
-  testContractRelativePath: string | undefined,
-  testContractDeployArgs: string | undefined,
-  testContractType: string | undefined,
-): string => {
-  if (
-    !testContractProjectRootPath ||
-    !testContractName ||
-    !testContractConfigFileName ||
-    !testContractRelativePath ||
-    !testContractDeployArgs ||
-    !testContractType
-  ) {
-    return '';
-  }
-
-  const artifactJsonPath = `${testContractProjectRootPath}/artifacts/${testContractName}.json`;
-  const configJsonPath = `${testContractProjectRootPath}/config/${testContractConfigFileName}.json`;
-  const fieldsToPickFromConfig = testContractDeployArgs.split(',');
-
-  const artifact = require(artifactJsonPath) as {
-    abi: ethers.ContractInterface;
-    bytecode: string;
-  };
-  // I don't want to type this testing thing. If something is wrong, I will just throw
-  const config = require(configJsonPath) as any;
-  const factory = new ethers.ContractFactory(artifact.abi, artifact.bytecode);
-
-  const args = fieldsToPickFromConfig.map(f => {
-    const value = config[f];
-    if (value === undefined) {
-      console.log(
-        `Field ${f} is not defined in configJsonPath=${configJsonPath}. Using value as it is`,
-      );
-      return f;
-    }
-    return value;
-  });
-
-  const deployedBytecode = factory.getDeployTransaction(...args).data;
-
-  assert(deployedBytecode !== undefined, 'deployedBytecode is undefined');
-
-  return deployedBytecode.toString();
-};

package/tests/v6/utils-e2e-v6.ts

@@ -1,103 +0,0 @@
-import { OptimalRate, SwapSide } from '@paraswap/core';
-import { ETHER_ADDRESS } from '../../src/constants';
-import {
-  IParaSwapSDK,
-  LocalParaswapSDK,
-} from '../../src/implementations/local-paraswap-sdk';
-import { TenderlySimulator, StateOverride } from '../tenderly-simulation';
-import { assert } from 'ts-essentials';
-
-export type ContractsAugustusV6 = {
-  AugustusV6: string;
-  Executor01: string;
-  Executor02: string;
-  Executor03: string;
-};
-
-const getAllExchanges = (data: OptimalRate): string[] => {
-  const exchanges = new Set<string>();
-
-  data.bestRoute.forEach(route => {
-    route.swaps.forEach(swap => {
-      swap.swapExchanges.forEach(swapExchange => {
-        exchanges.add(swapExchange.exchange);
-      });
-    });
-  });
-
-  return Array.from(exchanges);
-};
-
-export async function runE2ETest(
-  priceRoute: OptimalRate,
-  senderAddress: string,
-  contracts: ContractsAugustusV6,
-) {
-  // extract data from priceRoute
-  const { network, srcToken, side, srcAmount } = priceRoute;
-  // log the route for visibility
-  console.log('Price Route:', JSON.stringify(priceRoute, null, 2));
-  // The API currently doesn't allow for specifying poolIdentifiers
-  const paraswap: IParaSwapSDK = new LocalParaswapSDK(
-    network,
-    getAllExchanges(priceRoute),
-    '',
-  );
-  paraswap.dexHelper!.config.data.augustusV6Address = contracts.AugustusV6;
-  paraswap.dexHelper!.config.data.executorsAddresses = { ...contracts };
-  // initialize pricing
-  await paraswap.initializePricing?.();
-  // prepare state overrides
-  const tenderlySimulator = TenderlySimulator.getInstance();
-  // init `StateOverride` object
-  const stateOverride: StateOverride = {};
-  // fund x2 just in case
-  const amountToFund = BigInt(srcAmount) * 2n;
-  // add allowance override to Augustus
-  if (srcToken.toLowerCase() !== ETHER_ADDRESS) {
-    await tenderlySimulator.addAllowanceOverride(
-      stateOverride,
-      network,
-      srcToken,
-      senderAddress,
-      contracts.AugustusV6,
-      amountToFund,
-    );
-  }
-  // Calculate slippage. Default is 1%
-  const _slippage = BigInt(100);
-  const minMaxAmount =
-    (side === SwapSide.SELL
-      ? BigInt(priceRoute.destAmount) * (10000n - _slippage)
-      : BigInt(priceRoute.srcAmount) * (10000n + _slippage)) / 10000n;
-  const swapParams = await paraswap.buildTransaction(
-    priceRoute,
-    minMaxAmount,
-    senderAddress,
-  );
-  assert(
-    swapParams.to !== undefined,
-    'Transaction params missing `to` property',
-  );
-  // assemble `SimulationRequest`
-  const { from, to, data, value } = swapParams;
-  const simulationRequest = {
-    chainId: network,
-    from,
-    to,
-    data,
-    value,
-    blockNumber: priceRoute.blockNumber,
-    stateOverride,
-  };
-  // simulate the transaction with overrides
-  const simulation = await tenderlySimulator.simulateTransaction(
-    simulationRequest,
-  );
-  // release
-  if (paraswap.releaseResources) {
-    await paraswap.releaseResources();
-  }
-  // assert simulation status
-  expect(simulation.status).toEqual(true);
-}

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "allowSyntheticDefaultImports": true,
-    "lib": ["ESNext"],
-    "module": "commonjs",
-    "noImplicitAny": true,
-    "outDir": "build",
-    "rootDir": "src",
-    "preserveConstEnums": true,
-    "strictNullChecks": true,
-    "strict": true,
-    "sourceMap": true,
-    "declaration": true,
-    "skipLibCheck": true,
-    "target": "ESNext",
-    "resolveJsonModule": true,
-    "allowJs": true,
-    "typeRoots": ["node_modules/@types"],
-    "esModuleInterop": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["**/*.test.ts"]
-}