@paraswap/dex-lib 2.50.6 → 2.50.7-sdai

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

@@ -0,0 +1,148 @@
+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 { SDai } from './sdai';
+
+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 = 'SDai';
+const dexHelper = new DummyDexHelper(network);
+let blocknumber: number;
+let sdai: SDai;
+
+describe('SDai', function () {
+  beforeAll(async () => {
+    blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    sdai = new SDai(network, dexKey, dexHelper);
+    if (sdai.initializePricing) {
+      await sdai.initializePricing(blocknumber);
+    }
+  });
+
+  it('getPoolIdentifiers and getPricesVolume DAI -> sDAI SELL', async function () {
+    const pools = await sdai.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.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 sdai.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.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 sdai.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.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 sdai.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.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 sdai.getTopPoolsForToken(DaiToken.address, 10);
+    console.log(`${DaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, DaiToken.address, dexKey);
+  });
+
+  it('SDai getTopPoolsForToken', async function () {
+    const poolLiquidity = await sdai.getTopPoolsForToken(SDaiToken.address, 10);
+    console.log(`${SDaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, SDaiToken.address, dexKey);
+  });
+});

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

@@ -0,0 +1,113 @@
+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 { SDaiPoolState } 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: SDaiPoolState, 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 SDaiEventPool extends StatefulEventSubscriber<SDaiPoolState> {
+  constructor(
+    parentName: string,
+    protected dexHelper: IDexHelper,
+    private potAddress: Address,
+    private potInterface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, 'sdai', dexHelper, logger);
+    this.addressesSubscribed = [potAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<SDaiPoolState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): AsyncOrSync<DeepReadonly<SDaiPoolState> | 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<SDaiPoolState>> {
+    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;
+  }
+}

package/src/dex/sdai/sdai.ts

@@ -0,0 +1,233 @@
+import { SimpleExchange } from '../simple-exchange';
+import { IDex } from '../idex';
+import { SDaiParams, SDaiData, SDaiFunctions } from './types';
+import { Network, SwapSide } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { Adapters, SDaiConfig } from './config';
+import {
+  AdapterExchangeParam,
+  Address,
+  ExchangePrices,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  SimpleExchangeParam,
+  Token,
+} from '../../types';
+import { IDexHelper } from '../../dex-helper';
+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 { SDaiEventPool } from './sdai-pool';
+import { BI_POWS } from '../../bigint-constants';
+import { SDAI_DEPOSIT_GAS_COST, SDAI_REDEEM_GAS_COST } from './constants';
+
+export class SDai extends SimpleExchange implements IDex<SDaiData, SDaiParams> {
+  readonly hasConstantPriceLargeAmounts = true;
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(SDaiConfig);
+
+  public readonly eventPool: SDaiEventPool;
+  logger: Logger;
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+
+    readonly daiAddress: string = SDaiConfig[dexKey][network].daiAddress,
+    readonly sdaiAddress: string = SDaiConfig[dexKey][network].sdaiAddress,
+    readonly potAddress: string = SDaiConfig[dexKey][network].potAddress,
+
+    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 SDaiEventPool(
+      this.dexKey,
+      dexHelper,
+      this.potAddress,
+      this.potInterface,
+      this.logger,
+    );
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side] || null;
+  }
+
+  isSDai(tokenAddress: Address) {
+    return this.sdaiAddress.toLowerCase() === tokenAddress.toLowerCase();
+  }
+
+  isDai(tokenAddress: Address) {
+    return this.daiAddress.toLowerCase() === tokenAddress.toLowerCase();
+  }
+
+  isAppropriatePair(srcToken: Token, destToken: Token) {
+    return (
+      (this.isDai(srcToken.address) && this.isSDai(destToken.address)) ||
+      (this.isDai(destToken.address) && this.isSDai(srcToken.address))
+    );
+  }
+
+  async initializePricing(blockNumber: number) {
+    await this.eventPool.initialize(blockNumber);
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    return this.isAppropriatePair(srcToken, destToken)
+      ? [`${this.dexKey}_${this.sdaiAddress}`]
+      : [];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<SDaiData>> {
+    if (!this.isAppropriatePair(srcToken, destToken)) return null;
+    if (!this.eventPool.getState(blockNumber)) return null;
+
+    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}`],
+        },
+      ];
+    } 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}`],
+        },
+      ];
+    }
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(poolPrices: PoolPrices<SDaiData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.isDai(tokenAddress) && !this.isSDai(tokenAddress)) return [];
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.sdaiAddress,
+        connectorTokens: [
+          {
+            decimals: 18,
+            address: this.isDai(tokenAddress)
+              ? this.sdaiAddress
+              : this.daiAddress,
+          },
+        ],
+        liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+      },
+    ];
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: SDaiData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const isSell = side === SwapSide.SELL;
+    const { exchange } = data;
+
+    let swapData: string;
+    if (this.isDai(srcToken)) {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SDaiFunctions.deposit : SDaiFunctions.mint,
+        [isSell ? srcAmount : destAmount, this.augustusAddress],
+      );
+    } else {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SDaiFunctions.redeem : SDaiFunctions.withdraw,
+        [
+          isSell ? srcAmount : destAmount,
+          this.augustusAddress,
+          this.augustusAddress,
+        ],
+      );
+    }
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: SDaiData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { exchange } = data;
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          toStaked: 'bool',
+        },
+      },
+      {
+        toStaked: this.isDai(srcToken),
+      },
+    );
+
+    return {
+      targetExchange: exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+}

package/src/dex/sdai/types.ts

@@ -0,0 +1,23 @@
+import { Address } from '../../types';
+
+export type SDaiData = { exchange: Address };
+
+export type SDaiParams = {
+  sdaiAddress: Address;
+  daiAddress: Address;
+  potAddress: Address;
+};
+
+export enum SDaiFunctions {
+  deposit = 'deposit',
+  redeem = 'redeem',
+  withdraw = 'withdraw',
+  mint = 'mint',
+}
+
+export type SDaiPoolState = {
+  rho: string;
+  chi: string;
+  dsr: string;
+  live: boolean;
+};

package/src/dex/sdai/utils.ts

@@ -0,0 +1,48 @@
+import { Contract } from 'web3-eth-contract';
+import { SDaiPoolState } from './types';
+import { Interface, AbiCoder } from '@ethersproject/abi';
+import { currentBigIntTimestampInS } from '../../utils';
+
+const coder = new AbiCoder();
+
+// - `dsr`: the Dai Savings Rate
+// - `chi`: the Rate Accumulator
+// - `rho`: time of last drip
+export async function getOnChainState(
+  multiContract: Contract,
+  potAddress: string,
+  potInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SDaiPoolState> {
+  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', []),
+      },
+    ])
+    .call({}, blockNumber);
+
+  const [dsr, chi, rho, live] = data.returnData.map(item =>
+    coder.decode(['uint256'], item)[0].toString(),
+  );
+
+  return {
+    live: !!live,
+    dsr,
+    chi,
+    rho,
+  };
+}

package/tests/constants-e2e.ts

@@ -1096,7 +1096,7 @@ export const Holders: {
     USDT: '0x8A446971dbB112f3be15bc38C14D44B94D9E94b9',
     XAUT: '0xc4e161e8d8a4bc4ac762ab33a28bbac5474203d7',
     R: '0xBfe4c9D3235475C138a61f62e9e72FaD94A3303b',
-    sDAI: '0x8846163Fedc6b881526A6B48321601b474D40923',
+    sDAI: '0x4C612E3B15b96Ff9A6faED838F8d07d479a8dD4c',
     CVX: '0x0aCA67Fa70B142A3b9bF2eD89A81B40ff85dACdC',
     MIM: '0xa046a8660e66d178ee07ec97c585eeb6aa18c26c',
     AnkETH: '0xF7260D4ADc48fEefd5a19a9Eb23f9747CeE15C92',
@@ -1271,7 +1271,7 @@ export const Holders: {
     nETH: '0xcf2ef00e75558512ae735679ea5df62ad2056786',
     avWETH: '0x92d78e32b990d10aeca0875dc5585f1a6f958179',
     YUSD: '0x6c1a5ef2acde1fd2fc68def440d2c1eb35bae24a',
-    BTCb: '0x84c06d3c27821d0136f66306f5028d43ceac268d',
+    BTCb: '0x4bb7f4c3d47C4b431cb0658F44287d52006fb506',
     AMPL: '0xfcaA5ea7F8eb0631BcA72C345025C0A5a6D93f0E',
     PHAR: '0x654296D56532f62B7d91d335791d3c364a9385b5',
   },

package/.vscode/launch.json

@@ -1,53 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Current",
-      "program": "${file}",
-      "preLaunchTask": "npm: build",
-      "sourceMaps": true,
-      "smartStep": true,
-      "internalConsoleOptions": "openOnSessionStart",
-      "outFiles": ["${workspaceFolder}/build/**/*.js"]
-    },
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Debug dex integration",
-      "program": "${workspaceFolder}/node_modules/ts-node/dist/bin.js",
-      "args": [
-        "--project",
-        "tsconfig.json",
-        // "${workspaceFolder}/src/dex/algebra/scripts/validate-state.ts",
-        "${workspaceFolder}/src/dex/camelot/camelot-pool-discovery.test.ts",
-        // "${workspaceFolder}/src/dex/solidly-v3/scripts/check-event-pool-event.ts",
-        // "${workspaceFolder}/scripts/dex-integration.ts",
-        "test",
-        "wombat"
-      ],
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "runtimeArgs": ["--nolazy"],
-      "sourceMaps": true,
-      "smartStep": true,
-      "skipFiles": ["<node_internals>/**"],
-      "cwd": "${workspaceFolder}"
-    },
-    {
-      "type": "node",
-      "name": "Jest file",
-      "request": "launch",
-      "program": "${workspaceFolder}/node_modules/jest/bin/jest.js",
-      // "program": "${workspaceFolder}/src/dex/camelot/scripts/validate-state.ts",
-      // "args": ["src/dex/balancer-v1/balancer-v1-e2e.test.ts"],
-      // "args": ["${relativeFile}"],
-      "args": ["${file}"],
-      "cwd": "${workspaceRoot}",
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "sourceMaps": true
-    }
-  ]
-}

package/.vscode/settings.json

@@ -1,2 +0,0 @@
-{
-}

package/.vscode/tasks.json

@@ -1,15 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "tsc: build - tsconfig.json",
-      "type": "typescript",
-      "tsconfig": "tsconfig.json",
-      "problemMatcher": ["$tsc"],
-      "group": {
-        "kind": "build",
-        "isDefault": true
-      }
-    }
-  ]
-}