@paraswap/dex-lib 3.8.36 → 3.8.38

package/src/dex/spark/spark.ts

@@ -1,6 +1,11 @@
 import { SimpleExchange } from '../simple-exchange';
 import { Context, IDex } from '../idex';
-import { SparkParams, SparkData, SparkSDaiFunctions } from './types';
+import {
+  SparkParams,
+  SparkData,
+  SparkSDaiFunctions,
+  SparkSDaiPoolState,
+} from './types';
 import { Network, SwapSide } from '../../constants';
 import { getDexKeysWithNetwork } from '../../utils';
 import { Adapters, SDaiConfig } from './config';
@@ -21,7 +26,7 @@ import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
 import PotAbi from '../../abi/maker-psm/pot.json';
 import SavingsDaiAbi from '../../abi/sdai/SavingsDai.abi.json';
 import { Interface } from 'ethers/lib/utils';
-import { SparkSDaiEventPool } from './spark-sdai-pool';
+import { calcChi, RAY, SparkSDaiEventPool } from './spark-sdai-pool';
 import { BI_POWS } from '../../bigint-constants';
 import { SDAI_DEPOSIT_GAS_COST, SDAI_REDEEM_GAS_COST } from './constants';
 import { extractReturnAmountPosition } from '../../executor/utils';
@@ -42,25 +47,29 @@ export class Spark
   constructor(
     protected network: Network,
     dexKey: string,
-    protected dexHelper: IDexHelper,
+    readonly dexHelper: IDexHelper,
 
     readonly daiAddress: string = SDaiConfig[dexKey][network].daiAddress,
     readonly sdaiAddress: string = SDaiConfig[dexKey][network].sdaiAddress,
     readonly potAddress: string = SDaiConfig[dexKey][network].potAddress,
+    readonly abiInterface: Interface = SDaiConfig[dexKey][network]
+      .poolInterface,
 
     protected adapters = Adapters[network] || {},
     protected sdaiInterface = new Interface(SavingsDaiAbi),
-    protected potInterface = new Interface(PotAbi),
   ) {
     super(dexHelper, dexKey);
     this.logger = dexHelper.getLogger(dexKey);
     this.eventPool = new SparkSDaiEventPool(
       this.dexKey,
+      this.network,
       `${this.daiAddress}_${this.sdaiAddress}`,
       dexHelper,
       this.potAddress,
-      this.potInterface,
+      this.abiInterface,
       this.logger,
+      SDaiConfig[dexKey][network].savingsRate.topic,
+      SDaiConfig[dexKey][network].savingsRate.symbol,
     );
   }
 
@@ -107,41 +116,38 @@ export class Spark
     limitPools?: string[],
   ): Promise<null | ExchangePrices<SparkData>> {
     if (!this.isAppropriatePair(srcToken, destToken)) return null;
-    if (!this.eventPool.getState(blockNumber)) return null;
+    const state = this.eventPool.getState(blockNumber);
+    if (!state) return null;
+
+    const isSrcAsset = this.isDai(srcToken.address);
+
+    let calcFunction: Function;
 
     if (side === SwapSide.SELL) {
-      const calcSellFn = (blockNumber: number, amountIn: bigint) =>
-        this.isDai(srcToken.address)
-          ? this.eventPool.convertToSDai(amountIn, blockNumber)
-          : this.eventPool.convertToDai(amountIn, blockNumber);
-
-      return [
-        {
-          prices: amounts.map(amount => calcSellFn(blockNumber, amount)),
-          unit: calcSellFn(blockNumber, BI_POWS[18]),
-          gasCost: SDAI_DEPOSIT_GAS_COST,
-          exchange: this.dexKey,
-          data: { exchange: `${this.sdaiAddress}` },
-          poolAddresses: [`${this.sdaiAddress}`],
-        },
-      ];
+      if (isSrcAsset) {
+        calcFunction = this.previewDeposit.bind(this);
+      } else {
+        calcFunction = this.previewRedeem.bind(this);
+      }
     } else {
-      const calcBuyFn = (blockNumber: number, amountIn: bigint) =>
-        this.isDai(srcToken.address)
-          ? this.eventPool.convertToDai(amountIn, blockNumber)
-          : this.eventPool.convertToSDai(amountIn, blockNumber);
-
-      return [
-        {
-          prices: amounts.map(amount => calcBuyFn(blockNumber, amount)),
-          unit: calcBuyFn(blockNumber, BI_POWS[18]),
-          gasCost: SDAI_REDEEM_GAS_COST,
-          exchange: this.dexKey,
-          data: { exchange: `${this.sdaiAddress}` },
-          poolAddresses: [`${this.sdaiAddress}`],
-        },
-      ];
+      if (isSrcAsset) {
+        calcFunction = this.previewMint.bind(this);
+      } else {
+        calcFunction = this.previewWithdraw.bind(this);
+      }
     }
+
+    return [
+      {
+        // cannot produce 1:1 price without making an rpc call for block.timestamp and using it for price calculation in `calcChi` function
+        prices: amounts.map(amount => calcFunction(amount, state)),
+        unit: BI_POWS[18],
+        gasCost: SDAI_DEPOSIT_GAS_COST,
+        exchange: this.dexKey,
+        data: { exchange: `${this.sdaiAddress}` },
+        poolAddresses: [`${this.sdaiAddress}`],
+      },
+    ];
   }
 
   // Returns estimated gas cost of calldata for this DEX in multiSwap
@@ -286,4 +292,24 @@ export class Spark
       networkFee: '0',
     };
   }
+
+  previewRedeem(shares: bigint, state: SparkSDaiPoolState) {
+    return (shares * calcChi(state)) / RAY;
+  }
+
+  previewMint(shares: bigint, state: SparkSDaiPoolState) {
+    return this.divUp(shares * calcChi(state), RAY);
+  }
+
+  previewWithdraw(assets: bigint, state: SparkSDaiPoolState) {
+    return this.divUp(assets * RAY, calcChi(state));
+  }
+
+  previewDeposit(assets: bigint, state: SparkSDaiPoolState) {
+    return (assets * RAY) / calcChi(state);
+  }
+
+  divUp(x: bigint, y: bigint): bigint {
+    return x !== 0n ? (x - 1n) / y + 1n : 0n;
+  }
 }

package/src/dex/spark/types.ts

@@ -1,3 +1,4 @@
+import { Interface } from '@ethersproject/abi';
 import { Address } from '../../types';
 
 export type SparkData = { exchange: Address };
@@ -6,6 +7,11 @@ export type SparkParams = {
   sdaiAddress: Address;
   daiAddress: Address;
   potAddress: Address;
+  savingsRate: {
+    symbol: 'dsr' | 'ssr';
+    topic: string;
+  };
+  poolInterface: Interface;
 };
 
 export enum SparkSDaiFunctions {

package/src/dex/spark/utils.ts

@@ -4,34 +4,60 @@ import { Interface, AbiCoder } from '@ethersproject/abi';
 
 const coder = new AbiCoder();
 
-// - `dsr`: the Dai Savings Rate
+// - `dsr` || `ssr`: the Dai Savings Rate or USDS savings rate
 // - `chi`: the Rate Accumulator
 // - `rho`: time of last drip
 export async function getOnChainState(
   multiContract: Contract,
   potAddress: string,
   potInterface: Interface,
+  savingsRateSymbol: 'dsr' | 'ssr',
   blockNumber: number | 'latest',
 ): Promise<SparkSDaiPoolState> {
+  if (savingsRateSymbol === 'dsr') {
+    return getOnChainStateSDAI(
+      multiContract,
+      potAddress,
+      potInterface,
+      blockNumber,
+    );
+  }
+
+  return getOnChainStateUSDS(
+    multiContract,
+    potAddress,
+    potInterface,
+    blockNumber,
+  );
+}
+
+export async function getOnChainStateSDAI(
+  multiContract: Contract,
+  potAddress: string,
+  potInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SparkSDaiPoolState> {
+  const calls = [
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('dsr', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('chi', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('rho', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('live', []),
+    },
+  ];
+
   const data: { returnData: any[] } = await multiContract.methods
-    .aggregate([
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('dsr', []),
-      },
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('chi', []),
-      },
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('rho', []),
-      },
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('live', []),
-      },
-    ])
+    .aggregate(calls)
     .call({}, blockNumber);
 
   const [dsr, chi, rho, live] = data.returnData.map(item =>
@@ -45,3 +71,41 @@ export async function getOnChainState(
     rho,
   };
 }
+
+export async function getOnChainStateUSDS(
+  multiContract: Contract,
+  potAddress: string,
+  potInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SparkSDaiPoolState> {
+  const calls = [
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('ssr', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('chi', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('rho', []),
+    },
+  ];
+
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate(calls)
+    .call({}, blockNumber);
+
+  const [dsr, chi, rho] = data.returnData.map(item =>
+    coder.decode(['uint256'], item)[0].toString(),
+  );
+
+  return {
+    // 'hack' - sUSDS doesn't have global shutdown and no notion of `live`, so it's always `live`
+    live: true,
+    dsr,
+    chi,
+    rho,
+  };
+}

package/src/dex/usual-bond/config.ts

@@ -0,0 +1,12 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+export const UsualBondConfig: DexConfigMap<DexParams> = {
+  UsualBond: {
+    [Network.MAINNET]: {
+      usd0Address: '0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5',
+      usd0ppAddress: '0x35D8949372D46B7a3D5A56006AE77B215fc69bC0',
+    },
+  },
+};

package/src/dex/usual-bond/types.ts

@@ -0,0 +1,10 @@
+import { Address } from '../../types';
+
+export type PoolState = {};
+
+export type UsualBondData = {};
+
+export type DexParams = {
+  usd0Address: Address;
+  usd0ppAddress: Address;
+};

package/src/dex/usual-bond/usual-bond-e2e.test.ts

@@ -0,0 +1,80 @@
+/* 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,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+  ]);
+
+  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,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('UsualBond E2E', () => {
+  const dexKey = 'UsualBond';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'USD0';
+    const tokenBSymbol: string = 'USD0++';
+
+    const tokenAAmount: string = '100000';
+    const tokenBAmount: string = '100000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

package/src/dex/usual-bond/usual-bond-integration.test.ts

@@ -0,0 +1,144 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { UsualBond } from './usual-bond';
+import {
+  checkPoolPrices,
+  checkConstantPoolPrices,
+  checkPoolsLiquidity,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+
+async function testPricingOnNetwork(
+  usualBond: UsualBond,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenAddress: string,
+  destTokenAddress: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  console.log(amounts);
+
+  const pools = await usualBond.getPoolIdentifiers(
+    networkTokens['USD0'],
+    networkTokens['USD0++'],
+    side,
+    blockNumber,
+  );
+  console.log(`${'USD0'} <> ${'USD0++'} Pool Identifiers: `, pools);
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await usualBond.getPricesVolume(
+    networkTokens['USD0'],
+    networkTokens['USD0++'],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(`${'USD0'} <> ${'USD0++'} Pool Prices: `, poolPrices);
+
+  expect(poolPrices).not.toBeNull();
+  if (usualBond.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check if onchain pricing equals to calculated ones
+  checkPoolPrices(poolPrices!, amounts, side, dexKey);
+}
+
+describe('UsualBond', function () {
+  const dexKey = 'UsualBond';
+  let blockNumber: number;
+  let usualBond: UsualBond;
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    // Don't forget to update relevant tokens in constant-e2e.ts
+
+    const amountsForSell = [
+      0n,
+      1n * BI_POWS[18],
+      2n * BI_POWS[18],
+      3n * BI_POWS[18],
+      4n * BI_POWS[18],
+      5n * BI_POWS[18],
+      6n * BI_POWS[18],
+      7n * BI_POWS[18],
+      8n * BI_POWS[18],
+      9n * BI_POWS[18],
+      10n * BI_POWS[18],
+    ];
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      usualBond = new UsualBond(network, dexKey, dexHelper);
+      if (usualBond.initializePricing) {
+        await usualBond.initializePricing(blockNumber);
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      await testPricingOnNetwork(
+        usualBond,
+        network,
+        dexKey,
+        blockNumber,
+        'USD0',
+        'USD0++',
+        SwapSide.SELL,
+        amountsForSell,
+        '',
+      );
+    });
+
+    it('getTopPoolsForToken: USD0', async function () {
+      const tokenA = Tokens[network]['USD0'];
+      const dexHelper = new DummyDexHelper(network);
+      const usualBond = new UsualBond(network, dexKey, dexHelper);
+
+      const poolLiquidity = await usualBond.getTopPoolsForToken(
+        tokenA.address,
+        10,
+      );
+      console.log(
+        `${tokenA.symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+    });
+
+    it('getTopPoolsForToken: USD0++', async function () {
+      const tokenA = Tokens[network]['USD0++'];
+      const dexHelper = new DummyDexHelper(network);
+      const usualBond = new UsualBond(network, dexKey, dexHelper);
+
+      const poolLiquidity = await usualBond.getTopPoolsForToken(
+        tokenA.address,
+        10,
+      );
+      console.log(
+        `${tokenA.symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+    });
+  });
+});