@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.4

package/src/dex/spark/config.ts

@@ -0,0 +1,25 @@
+import { SparkParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+import { SwapSide } from '@paraswap/core';
+
+export const SDaiConfig: DexConfigMap<SparkParams> = {
+  Spark: {
+    [Network.MAINNET]: {
+      sdaiAddress: '0x83F20F44975D03b1b09e64809B757c47f942BEeA',
+      daiAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+      potAddress: '0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7',
+    },
+  },
+};
+
+export const Adapters: {
+  [chainId: number]: {
+    [side: string]: { name: string; index: number }[];
+  };
+} = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [{ name: 'Adapter06', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 4 }],
+  },
+};

package/src/dex/spark/constants.ts

@@ -0,0 +1,2 @@
+export const SDAI_DEPOSIT_GAS_COST = 165_000;
+export const SDAI_REDEEM_GAS_COST = 90_000;

package/src/dex/spark/scripts/validate-state.ts

@@ -0,0 +1,144 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Network } from '../../../constants';
+import { DummyDexHelper } from '../../../dex-helper';
+import { SparkSDaiPoolState } from '../types';
+import { BlockHeader } from 'web3-eth';
+import { ethers } from 'ethers';
+import { Spark } from '../spark';
+import { SDaiConfig } from '../config';
+import { getOnChainState } from '../utils';
+import { Interface } from '@ethersproject/abi';
+import PotAbi from '../../../abi/maker-psm/pot.json';
+
+const network = Network.MAINNET;
+const dexKey = 'Spark';
+
+const { potAddress } = SDaiConfig[dexKey][network];
+const blockHeaders: Record<number, BlockHeader> = {};
+
+const dexHelper = new DummyDexHelper(network);
+const logger = dexHelper.getLogger(dexKey);
+
+function preprocessField(value: any): string {
+  if (
+    typeof value === 'bigint' ||
+    typeof value === 'number' ||
+    ethers.BigNumber.isBigNumber(value)
+  ) {
+    return value.toString();
+  }
+  return value;
+}
+
+function compareAndLogDifferences<T extends object, Y extends object>(
+  obj1: T,
+  obj2: Y,
+  keyNames: Array<keyof T & keyof Y>,
+  checkEachKey = false,
+) {
+  let isValid = true;
+  let keys = keyNames;
+
+  if (checkEachKey) {
+    // find common keys
+    const keys1 = Object.keys(obj1);
+    const keys2 = new Set(Object.keys(obj2));
+    keys = keys1.filter(key => keys2.has(key)) as Array<keyof T & keyof Y>;
+  }
+
+  for (let fieldName of keys) {
+    const value1 = preprocessField(obj1[fieldName]);
+    const value2 = preprocessField(obj2[fieldName]);
+
+    if (value1 !== value2) {
+      console.log(
+        `${fieldName.toString()} mismatch: actual: ${value1} vs pool: ${value2}`,
+      );
+      isValid = false;
+    }
+  }
+
+  return isValid;
+}
+
+async function isPoolStateEqualToReal(
+  state: SparkSDaiPoolState,
+  blockNumber: number,
+) {
+  const expected = await getOnChainState(
+    dexHelper.multiContract,
+    potAddress,
+    new Interface(PotAbi),
+    blockNumber,
+  );
+
+  const isValidState = compareAndLogDifferences(state, expected, [
+    'rho',
+    'dsr',
+    'dsr',
+  ]);
+
+  return isValidState;
+}
+
+async function checkPoolStateForBlockRange(
+  startBlockNumber: number,
+  endBlockNumber: number,
+): Promise<boolean> {
+  const network = Network.MAINNET;
+  const dexKey = 'Spark';
+  const dexHelper = new DummyDexHelper(network);
+
+  const spark = new Spark(network, dexKey, dexHelper);
+  const pool = await spark.eventPool;
+
+  const logsToDispatch = await dexHelper.provider.getLogs({
+    fromBlock: startBlockNumber,
+    toBlock: endBlockNumber,
+    address: potAddress,
+  });
+
+  console.log(logsToDispatch.length);
+
+  // group logs by block number
+  const logsByBlockNumber: Record<number, any[]> = {};
+  for (let log of logsToDispatch) {
+    if (!logsByBlockNumber[log.blockNumber]) {
+      logsByBlockNumber[log.blockNumber] = [];
+    }
+    logsByBlockNumber[log.blockNumber].push(log);
+  }
+
+  const sortedBlocks = Object.keys(logsByBlockNumber)
+    .map(Number)
+    .sort((a, b) => Number(a) - Number(b));
+
+  for (let blockNumber of sortedBlocks) {
+    if (!blockHeaders[blockNumber]) {
+      blockHeaders[blockNumber] = await dexHelper.web3Provider.eth.getBlock(
+        blockNumber,
+      );
+    }
+
+    await pool?.update(logsByBlockNumber[blockNumber], {
+      [blockNumber]: blockHeaders[blockNumber],
+    });
+  }
+
+  const state = pool?.getState(startBlockNumber) as SparkSDaiPoolState;
+  return isPoolStateEqualToReal(state, endBlockNumber);
+}
+
+async function main() {
+  // use findBreakingBlock to find the block where the state is broken
+  // console.log(await findBreakingBlock(startBlockNumber, endBlockNumber));
+  // previously broken block 150502863
+  console.log(await checkPoolStateForBlockRange(19199247 - 10000, 19199247));
+}
+
+main()
+  .then(() => console.log('Done'))
+  .catch(e => console.error(e));

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

@@ -0,0 +1,96 @@
+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';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[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,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('sDAI E2E', () => {
+  const dexKey = 'Spark';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'DAI';
+    const tokenBSymbol: string = 'sDAI';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

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

@@ -0,0 +1,102 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { SparkSDaiEventPool } from './spark-sdai-pool';
+import { SDaiConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { SparkSDaiPoolState } from './types';
+
+import PotAbi from '../../abi/maker-psm/pot.json';
+import { Interface } from '@ethersproject/abi';
+import _ from 'lodash';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for SDai event based
+  system. This is done by fetching the state on-chain before the
+  event block, manually pushing the block logs to the event-subscriber,
+  comparing the local state with on-chain state.
+
+  Most of the logic for testing is abstracted by `testEventSubscriber`.
+  You need to do two things to make the tests work:
+
+  1. Fetch the block numbers where certain events were released. You
+  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
+  block numbers for different events. Make sure to get sufficient
+  number of blockNumbers to cover all possible cases for the event
+  mutations.
+
+  2. Complete the implementation for fetchPoolState function. The
+  function should fetch the on-chain state of the event subscriber
+  using just the blocknumber.
+
+  The template tests only include the test for a single event
+  subscriber. There can be cases where multiple event subscribers
+  exist for a single DEX. In such cases additional tests should be
+  added.
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-events.test.ts`
+
+  (This comment should be removed from the final implementation)
+*/
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'Spark';
+const network = Network.MAINNET;
+
+async function fetchPoolState(
+  sdaiPool: SparkSDaiEventPool,
+  blockNumber: number,
+): Promise<SparkSDaiPoolState> {
+  return sdaiPool.generateState(blockNumber);
+}
+
+describe('SDai Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    drip: [19827559, 19827524, 19827163, 19827124, 19827000, 19826892],
+    // TODO: no matching logs, you have to manually call "file"
+    // from "0xbe8e3e3618f7474f8cb1d074a26affef007e98fb" address
+    // https://etherscan.io/advanced-filter?fadd=0x197e90f9fad81970ba7976f33cbd77088e5d7cf7&tadd=0x197e90f9fad81970ba7976f33cbd77088e5d7cf7&mtd=0x29ae8114%7eFile
+    // file: [19831086]
+  };
+
+  const addresses: { [contract: string]: string } = {
+    potAddress: SDaiConfig[dexKey][network].potAddress,
+  };
+
+  describe('SDaiPool', 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);
+          const logger = dexHelper.getLogger(dexKey);
+
+          const sdaiPool = new SparkSDaiEventPool(
+            dexKey,
+            `dai-sdai-pool`,
+            dexHelper,
+            addresses.potAddress,
+            new Interface(PotAbi),
+            logger,
+          );
+
+          await sdaiPool.initialize(blockNumber);
+
+          await testEventSubscriber(
+            sdaiPool,
+            sdaiPool.addressesSubscribed,
+            (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${sdaiPool}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/spark/spark-integration.test.ts

@@ -0,0 +1,151 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+import { Spark } from './spark';
+
+const network = Network.MAINNET;
+
+const SDaiSymbol = 'sDAI';
+const SDaiToken = Tokens[network][SDaiSymbol];
+
+const DaiSymbol = 'DAI';
+const DaiToken = Tokens[network][DaiSymbol];
+
+const amounts = [0n, BI_POWS[18], 2000000000000000000n];
+
+const dexKey = 'Spark';
+const dexHelper = new DummyDexHelper(network);
+let blocknumber: number;
+let spark: Spark;
+
+describe('Spark', function () {
+  beforeAll(async () => {
+    blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    spark = new Spark(network, dexKey, dexHelper);
+    if (spark.initializePricing) {
+      await spark.initializePricing(blocknumber);
+    }
+  });
+
+  it('getPoolIdentifiers and getPricesVolume DAI -> sDAI SELL', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sDAI -> DAI SELL', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume DAI -> sDAI BUY', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sDAI -> DAI BUY', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('Dai getTopPoolsForToken', async function () {
+    const poolLiquidity = await spark.getTopPoolsForToken(DaiToken.address, 10);
+    console.log(`${DaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, DaiToken.address, dexKey);
+  });
+
+  it('SDai getTopPoolsForToken', async function () {
+    const poolLiquidity = await spark.getTopPoolsForToken(
+      SDaiToken.address,
+      10,
+    );
+    console.log(`${SDaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, SDaiToken.address, dexKey);
+  });
+});

package/src/dex/spark/spark-sdai-pool.ts

@@ -0,0 +1,114 @@
+import { BI_POWS } from '../../bigint-constants';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Interface } from '@ethersproject/abi';
+
+import type { IDexHelper } from '../../dex-helper';
+import type { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import type { Address, BlockHeader, Log, Logger } from '../../types';
+import type { SparkSDaiPoolState } from './types';
+import { getOnChainState } from './utils';
+
+const RAY = BI_POWS[27];
+const ZERO = BigInt(0);
+const TWO = BigInt(2);
+const HALF = RAY / TWO;
+
+// function file(bytes32,uint256)
+const FILE_TOPICHASH = `0x29ae811400000000000000000000000000000000000000000000000000000000`;
+// function drip()
+const DRIP_TOPICHASH = `0x9f678cca00000000000000000000000000000000000000000000000000000000`;
+// function cage()
+const CAGE_TOPICHASH = `0x6924500900000000000000000000000000000000000000000000000000000000`;
+// bytes32 repr of "dsr" string
+const DSR_TOPIC = `0x6473720000000000000000000000000000000000000000000000000000000000`;
+
+const rpow = (x: bigint, n: bigint): bigint => {
+  if (!x && !n) return RAY;
+  if (!x) return ZERO;
+
+  let z = n % TWO > ZERO ? x : RAY;
+
+  for (n = n / TWO; n; n /= TWO) {
+    x = (x * x + HALF) / RAY;
+    if (n % TWO > ZERO) {
+      z = (z * x + HALF) / RAY;
+    }
+  }
+
+  return z;
+};
+
+const calcChi = (state: SparkSDaiPoolState, currentTimestamp?: number) => {
+  currentTimestamp ||= Math.floor(Date.now() / 1000);
+  if (!state.live) return RAY;
+
+  const { dsr: dsr_, chi: chi_, rho: rho_ } = state;
+  const now = BigInt(currentTimestamp);
+  const rho = BigInt(rho_);
+  const dsr = BigInt(dsr_);
+  const chi = BigInt(chi_);
+
+  return now > rho ? (rpow(dsr, now - rho) * chi) / RAY : chi;
+};
+
+export class SparkSDaiEventPool extends StatefulEventSubscriber<SparkSDaiPoolState> {
+  constructor(
+    parentName: string,
+    poolName: string,
+    protected dexHelper: IDexHelper,
+    private potAddress: Address,
+    private potInterface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, poolName, dexHelper, logger);
+    this.addressesSubscribed = [potAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<SparkSDaiPoolState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): AsyncOrSync<DeepReadonly<SparkSDaiPoolState> | null> {
+    if (log.topics[0] === FILE_TOPICHASH && log.topics[2] === DSR_TOPIC) {
+      return {
+        ...state,
+        dsr: BigInt(log.topics[3]).toString(),
+      };
+    }
+
+    if (log.topics[0] === DRIP_TOPICHASH) {
+      return {
+        ...state,
+        rho: blockHeader.timestamp.toString(),
+        chi: calcChi(state, +blockHeader.timestamp).toString(),
+      };
+    }
+
+    return null;
+  }
+
+  async generateState(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<DeepReadonly<SparkSDaiPoolState>> {
+    return getOnChainState(
+      this.dexHelper.multiContract,
+      this.potAddress,
+      this.potInterface,
+      blockNumber,
+    );
+  }
+
+  convertToSDai(daiAmount: bigint, blockNumber: number): bigint {
+    const state = this.getState(blockNumber);
+    if (!state) throw new Error(`SDai state at ${blockNumber} does not exists`);
+
+    return (daiAmount * RAY) / calcChi(state);
+  }
+
+  convertToDai(sdaiAmount: bigint, blockNumber: number): bigint {
+    const state = this.getState(blockNumber);
+    if (!state) throw new Error(`SDai state at ${blockNumber} does not exists`);
+
+    return (sdaiAmount * calcChi(state)) / RAY;
+  }
+}