@paraswap/dex-lib 4.1.12 → 4.1.13

package/src/dex/spark/spark-psm.ts

@@ -0,0 +1,361 @@
+import { Spark } from './spark';
+import { Address, NumberAsString } from '@paraswap/core';
+import {
+  SparkData,
+  SparkParams,
+  SparkSDaiPoolState,
+  SparkSUSDSPsmFunctions,
+} from './types';
+import { SwapSide } from '@paraswap/core/build/constants';
+import { Context } from '../idex';
+import {
+  DexConfigMap,
+  DexExchangeParam,
+  ExchangePrices,
+  PoolLiquidity,
+  Token,
+} from '../../types';
+import { Network } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { Interface } from '@ethersproject/abi';
+import SSRAuthOracleAbi from '../../abi/sdai/SSRAuthOracle.abi.json';
+import SparkPSM3Abi from '../../abi/sdai/PSM3.abi.json';
+import { IDexHelper } from '../../dex-helper';
+import { Adapters } from './config';
+import { extractReturnAmountPosition } from '../../executor/utils';
+import { BI_POWS } from '../../bigint-constants';
+import { SDAI_DEPOSIT_GAS_COST } from './constants';
+
+export const sUSDSPsmConfig: DexConfigMap<SparkParams> = {
+  SparkPsm: {
+    [Network.ARBITRUM]: {
+      sdaiAddress: '0xdDb46999F8891663a8F2828d25298f70416d7610', // sUSDS
+      sdaiDecimals: 18,
+      daiAddress: '0x6491c05A82219b8D1479057361ff1654749b876b', // USDS
+      daiDecimals: 18,
+      usdcAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC
+      usdcDecimals: 6,
+      potAddress: '0xEE2816c1E1eed14d444552654Ed3027abC033A36', // SSRAuthOracle contract address
+      psmAddress: '0x2B05F8e1cACC6974fD79A673a341Fe1f58d27266', // PSM contract address
+      savingsRate: {
+        symbol: 'ssrOracle',
+        topic:
+          '0xc234856e2a0c5b406365714ced016892e7d98f7b1d49982cdd8db416a586d811', // SetSUSDSData event
+      },
+      poolInterface: new Interface(SSRAuthOracleAbi),
+      exchangeInterface: new Interface(SparkPSM3Abi),
+      swapFunctions: SparkSUSDSPsmFunctions,
+      referralCode: '1004',
+    },
+    [Network.BASE]: {
+      sdaiAddress: '0x5875eEE11Cf8398102FdAd704C9E96607675467a', // sUSDS
+      sdaiDecimals: 18,
+      daiAddress: '0x820C137fa70C8691f0e44Dc420a5e53c168921Dc', // USDS
+      daiDecimals: 18,
+      usdcAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+      usdcDecimals: 6,
+      potAddress: '0x65d946e533748A998B1f0E430803e39A6388f7a1', // SSRAuthOracle contract address
+      psmAddress: '0x1601843c5E9bC251A3272907010AFa41Fa18347E', // PSM contract address
+      savingsRate: {
+        symbol: 'ssrOracle',
+        topic:
+          '0x7373720000000000000000000000000000000000000000000000000000000000',
+      },
+      poolInterface: new Interface(SSRAuthOracleAbi),
+      exchangeInterface: new Interface(SparkPSM3Abi),
+      swapFunctions: SparkSUSDSPsmFunctions,
+      referralCode: '1004',
+    },
+  },
+};
+
+export class SparkPsm extends Spark {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(sUSDSPsmConfig);
+
+  protected readonly usdcAddress: string;
+  protected readonly daiPrecision: bigint;
+  protected readonly sDaiPrecision: bigint;
+  protected readonly usdcPrecision: bigint;
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    readonly dexHelper: IDexHelper,
+    protected readonly config = sUSDSPsmConfig[dexKey][network],
+    readonly daiAddress: string = sUSDSPsmConfig[dexKey][network].daiAddress,
+    readonly sdaiAddress: string = sUSDSPsmConfig[dexKey][network].sdaiAddress,
+    readonly potAddress: string = sUSDSPsmConfig[dexKey][network].potAddress,
+    readonly abiInterface: Interface = sUSDSPsmConfig[dexKey][network]
+      .poolInterface,
+
+    protected adapters = Adapters[network] || {},
+    protected sdaiInterface = sUSDSPsmConfig[dexKey][network].exchangeInterface,
+    protected swapFunctions = sUSDSPsmConfig[dexKey][network].swapFunctions,
+    protected referralCode = sUSDSPsmConfig[dexKey][network].referralCode,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      config,
+      daiAddress,
+      sdaiAddress,
+      potAddress,
+      abiInterface,
+      adapters,
+      sdaiInterface,
+      swapFunctions,
+      referralCode,
+    );
+
+    this.usdcAddress = config.usdcAddress!;
+    this.daiPrecision = 10n ** BigInt(config.daiDecimals!);
+    this.sDaiPrecision = 10n ** BigInt(config.sdaiDecimals!);
+    this.usdcPrecision = 10n ** BigInt(config.usdcDecimals!);
+  }
+
+  isUSDC(tokenAddress: Address) {
+    return this.usdcAddress.toLowerCase() === tokenAddress.toLowerCase();
+  }
+
+  isAppropriateTokenAddress(tokenAddress: string): boolean {
+    const supportedTokens = [
+      this.daiAddress.toLowerCase(),
+      this.usdcAddress.toLowerCase(),
+      this.sdaiAddress.toLowerCase(),
+    ];
+
+    return supportedTokens.indexOf(tokenAddress.toLowerCase()) > -1;
+  }
+
+  isAppropriatePair(srcToken: Token, destToken: Token): boolean {
+    if (srcToken.address.toLowerCase() === destToken.address.toLowerCase()) {
+      return false;
+    }
+
+    return (
+      this.isAppropriateTokenAddress(srcToken.address) &&
+      this.isAppropriateTokenAddress(destToken.address)
+    );
+  }
+
+  convertOneToOne(assetPrecision: bigint, convertAssetPrecision: bigint) {
+    return (assets: bigint): bigint => {
+      return (assets * convertAssetPrecision + assetPrecision) / assetPrecision;
+    };
+  }
+
+  previewSell(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    state: SparkSDaiPoolState,
+  ): bigint[] {
+    let calcFunction: Function;
+
+    const isDaiSrcAsset = this.isDai(srcToken.address);
+    const isUSDCToUSDS =
+      this.isUSDC(srcToken.address) && this.isDai(destToken.address);
+
+    const isUSDSToUSDC =
+      this.isDai(srcToken.address) && this.isUSDC(destToken.address);
+
+    const isUSDCSrcAsset = this.isUSDC(srcToken.address);
+    const isUSDCDestAsset = this.isUSDC(destToken.address);
+
+    if (isUSDCToUSDS) {
+      calcFunction = this.convertOneToOne(
+        this.usdcPrecision,
+        this.daiPrecision,
+      ).bind(this);
+    } else if (isUSDSToUSDC) {
+      calcFunction = this.convertOneToOne(
+        this.daiPrecision,
+        this.usdcPrecision,
+      ).bind(this);
+    } else if (isDaiSrcAsset) {
+      calcFunction = this.previewDeposit.bind(this);
+    } else {
+      if (isUSDCSrcAsset) {
+        calcFunction = (assets: bigint, state: SparkSDaiPoolState) => {
+          const res = this.previewDeposit(assets, state);
+          return (res * this.sDaiPrecision) / this.usdcPrecision;
+        };
+      } else if (isUSDCDestAsset) {
+        calcFunction = (assets: bigint, state: SparkSDaiPoolState) => {
+          const res = this.previewRedeem(assets, state);
+          return (res * this.usdcPrecision) / this.sDaiPrecision;
+        };
+      } else {
+        calcFunction = this.previewRedeem.bind(this);
+      }
+    }
+
+    return amounts.map(amount => calcFunction(amount, state));
+  }
+
+  previewBuy(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    state: SparkSDaiPoolState,
+  ): bigint[] {
+    let calcFunction: Function;
+
+    const isDaiSrcAsset = this.isDai(srcToken.address);
+    const isUSDCToUSDS =
+      this.isUSDC(srcToken.address) && this.isDai(destToken.address);
+
+    const isUSDSToUSDC =
+      this.isDai(srcToken.address) && this.isUSDC(destToken.address);
+
+    const isUSDCSrcAsset = this.isUSDC(srcToken.address);
+    const isUSDCDestAsset = this.isUSDC(destToken.address);
+
+    if (isUSDCToUSDS) {
+      calcFunction = this.convertOneToOne(
+        this.daiPrecision,
+        this.usdcPrecision,
+      ).bind(this);
+    } else if (isUSDSToUSDC) {
+      calcFunction = this.convertOneToOne(
+        this.usdcPrecision,
+        this.daiPrecision,
+      ).bind(this);
+    } else if (isDaiSrcAsset) {
+      calcFunction = this.previewMint.bind(this);
+    } else {
+      if (isUSDCSrcAsset) {
+        calcFunction = (assets: bigint, state: SparkSDaiPoolState) => {
+          const res = this.previewMint(assets, state);
+          return (res * this.usdcPrecision) / this.sDaiPrecision;
+        };
+      } else if (isUSDCDestAsset) {
+        calcFunction = (assets: bigint, state: SparkSDaiPoolState) => {
+          const res = this.previewWithdraw(assets, state);
+          return (res * this.sDaiPrecision) / this.usdcPrecision;
+        };
+      } else {
+        calcFunction = this.previewWithdraw.bind(this);
+      }
+    }
+
+    return amounts.map(amount => calcFunction(amount, state));
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<SparkData>> {
+    if (!this.isAppropriatePair(srcToken, destToken)) return null;
+    const state = this.eventPool.getState(blockNumber);
+    if (!state) return null;
+
+    let results: bigint[];
+    if (side === SwapSide.SELL) {
+      results = this.previewSell(srcToken, destToken, amounts, state);
+    } else {
+      results = this.previewBuy(srcToken, destToken, amounts, state);
+    }
+
+    return [
+      {
+        // cannot produce 1:1 price without making an rpc call for block.timestamp and using it for price calculation in `calcChi` function
+        prices: results,
+        unit: BI_POWS[18],
+        gasCost: SDAI_DEPOSIT_GAS_COST,
+        exchange: this.dexKey,
+        data: { exchange: `${this.sdaiAddress}` },
+        poolAddresses: [`${this.sdaiAddress}`],
+      },
+    ];
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.isAppropriateTokenAddress(tokenAddress)) return [];
+
+    const connectors = [
+      {
+        decimals: this.config.daiDecimals,
+        address: this.daiAddress,
+      },
+      {
+        decimals: this.config.sdaiDecimals,
+        address: this.sdaiAddress,
+      },
+      {
+        decimals: this.config.usdcDecimals,
+        address: this.usdcAddress,
+      },
+    ] as Token[];
+
+    const allPossiblePools = connectors.map(connenctor => ({
+      exchange: this.dexKey,
+      address: this.config.psmAddress!,
+      connectorTokens: [{ ...connenctor }],
+      liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+    }));
+
+    return allPossiblePools.filter(pool => {
+      const token = pool.connectorTokens[0];
+      return token.address.toLowerCase() !== tokenAddress.toLowerCase();
+    });
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SparkData,
+    side: SwapSide,
+    _: Context,
+    executorAddress: Address,
+  ): DexExchangeParam {
+    const isSell = side === SwapSide.SELL;
+    let swapData: string;
+
+    if (isSell) {
+      swapData = this.sdaiInterface.encodeFunctionData('swapExactIn', [
+        srcToken,
+        destToken,
+        srcAmount,
+        destAmount,
+        recipient,
+        this.config.referralCode,
+      ]);
+    } else {
+      swapData = this.sdaiInterface.encodeFunctionData('swapExactOut', [
+        srcToken,
+        destToken,
+        destAmount,
+        srcAmount,
+        recipient,
+        this.config.referralCode,
+      ]);
+    }
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.config.psmAddress!,
+      returnAmountPos: isSell
+        ? extractReturnAmountPosition(
+            this.sdaiInterface,
+            'swapExactIn',
+            'amountOut',
+          )
+        : undefined,
+    };
+  }
+}

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

@@ -7,7 +7,6 @@ import type { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import type { Address, BlockHeader, Log, Logger } from '../../types';
 import type { SparkSDaiPoolState } from './types';
 import { getOnChainState } from './utils';
-import { SDaiConfig } from './config';
 import { Network } from '../../constants';
 
 export const RAY = BI_POWS[27];
@@ -62,7 +61,7 @@ export class SparkSDaiEventPool extends StatefulEventSubscriber<SparkSDaiPoolSta
     private potInterface: Interface,
     logger: Logger,
     private savingsRateTopic: string,
-    private savingsRateSymbol: 'ssr' | 'dsr',
+    private savingsRateSymbol: 'ssr' | 'dsr' | 'ssrOracle',
   ) {
     super(parentName, poolName, dexHelper, logger);
     this.addressesSubscribed = [potAddress];

package/src/dex/spark/spark.ts

@@ -41,7 +41,7 @@ export class Spark
     protected network: Network,
     dexKey: string,
     readonly dexHelper: IDexHelper,
-
+    protected readonly config = SDaiConfig[dexKey][network],
     readonly daiAddress: string = SDaiConfig[dexKey][network].daiAddress,
     readonly sdaiAddress: string = SDaiConfig[dexKey][network].sdaiAddress,
     readonly potAddress: string = SDaiConfig[dexKey][network].potAddress,
@@ -63,8 +63,8 @@ export class Spark
       this.potAddress,
       this.abiInterface,
       this.logger,
-      SDaiConfig[dexKey][network].savingsRate.topic,
-      SDaiConfig[dexKey][network].savingsRate.symbol,
+      config.savingsRate.topic,
+      config.savingsRate.symbol,
     );
   }
 
@@ -236,6 +236,7 @@ export class Spark
     const { exchange } = data;
 
     let swapData: string;
+
     if (this.isDai(srcToken)) {
       const calldata = [isSell ? srcAmount : destAmount, recipient];
 

package/src/dex/spark/types.ts

@@ -5,15 +5,23 @@ export type SparkData = { exchange: Address };
 
 export type SparkParams = {
   sdaiAddress: Address;
+  sdaiDecimals?: number;
   daiAddress: Address;
+  daiDecimals?: number;
+  usdcAddress?: Address;
+  usdcDecimals?: number;
   potAddress: Address;
+  psmAddress?: Address;
   savingsRate: {
-    symbol: 'dsr' | 'ssr';
+    symbol: 'dsr' | 'ssr' | 'ssrOracle';
     topic: string;
   };
   poolInterface: Interface;
   exchangeInterface: Interface;
-  swapFunctions: typeof SparkSDaiFunctions | typeof SparkSUSDSFunctions;
+  swapFunctions:
+    | typeof SparkSDaiFunctions
+    | typeof SparkSUSDSFunctions
+    | typeof SparkSUSDSPsmFunctions;
   referralCode: null | string;
 };
 
@@ -31,6 +39,13 @@ export enum SparkSUSDSFunctions {
   mint = 'mint(uint256,address,uint16)',
 }
 
+export enum SparkSUSDSPsmFunctions {
+  deposit = 'swapExactIn(address,address,uint256)',
+  redeem = 'swapExactIn(address,address,uint256)',
+  withdraw = 'swapExactOut(address,address,uint256)',
+  mint = 'swapExactOut(address,address,uint256)',
+}
+
 export type SparkSDaiPoolState = {
   rho: string;
   chi: string;

package/src/dex/spark/utils.ts

@@ -11,7 +11,7 @@ export async function getOnChainState(
   multiContract: Contract,
   potAddress: string,
   potInterface: Interface,
-  savingsRateSymbol: 'dsr' | 'ssr',
+  savingsRateSymbol: 'dsr' | 'ssr' | 'ssrOracle',
   blockNumber: number | 'latest',
 ): Promise<SparkSDaiPoolState> {
   if (savingsRateSymbol === 'dsr') {
@@ -23,6 +23,15 @@ export async function getOnChainState(
     );
   }
 
+  if (savingsRateSymbol === 'ssrOracle') {
+    return getOnChainStateUSDSOracle(
+      multiContract,
+      potAddress,
+      potInterface,
+      blockNumber,
+    );
+  }
+
   return getOnChainStateUSDS(
     multiContract,
     potAddress,
@@ -72,6 +81,37 @@ export async function getOnChainStateSDAI(
   };
 }
 
+export async function getOnChainStateUSDSOracle(
+  multiContract: Contract,
+  potAddress: string,
+  potInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SparkSDaiPoolState> {
+  const calls = [
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('getSUSDSData', []),
+    },
+  ];
+
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate(calls)
+    .call({}, blockNumber);
+
+  const decoded = potInterface.decodeFunctionResult(
+    'getSUSDSData',
+    data.returnData[0],
+  );
+
+  return {
+    // 'hack' - sUSDS doesn't have global shutdown and no notion of `live`, so it's always `live`
+    live: true,
+    dsr: decoded[0].ssr.toString(),
+    chi: decoded[0].chi.toString(),
+    rho: decoded[0].rho.toString(),
+  };
+}
+
 export async function getOnChainStateUSDS(
   multiContract: Contract,
   potAddress: string,

package/tests/constants-e2e.ts

@@ -1394,6 +1394,14 @@ export const Tokens: {
       address: '0xe98fc055c99decd8da0c111b090885d5d15c774e',
       decimals: 18,
     },
+    USDS: {
+      address: '0x6491c05A82219b8D1479057361ff1654749b876b',
+      decimals: 18,
+    },
+    sUSDS: {
+      address: '0xdDb46999F8891663a8F2828d25298f70416d7610',
+      decimals: 18,
+    },
   },
   [Network.OPTIMISM]: {
     DAI: {
@@ -1747,6 +1755,10 @@ export const Tokens: {
       address: '0x5875eee11cf8398102fdad704c9e96607675467a',
       decimals: 18,
     },
+    USDS: {
+      address: '0x820C137fa70C8691f0e44Dc420a5e53c168921Dc',
+      decimals: 18,
+    },
     smUSDC: {
       address: '0x616a4e1db48e22028f6bbf20444cd3b8e3273738',
       decimals: 18,
@@ -1794,8 +1806,8 @@ export const Holders: {
 } = {
   [Network.MAINNET]: {
     FLUID: '0x2d675D4C52a8aE117b935fF98c6F9f29A15827F0',
-    USDS: '0xB1796E8f1eEcF23027c1E3C00fE303629A189d10',
-    sUSDS: '0xd564B3aE673CAa49D054Bf185bD72a6853763eE7',
+    USDS: '0x67A9e0F4Cc10C3F6cb55503e0888129039Ea7C90',
+    sUSDS: '0x0955F0D3729E035B9f5b808fEcd602B2891A32fc',
     SKY: '0x0ddda327A6614130CCb20bc0097313A282176A01',
     MKR: '0xe9aAA7A9DDc0877626C1779AbC29993aD89A6c1f',
     // Idle tokens
@@ -2098,6 +2110,8 @@ export const Holders: {
     USDM: '0x57F5E098CaD7A3D1Eed53991D4d66C45C9AF7812',
     wUSDM: '0x12c9cE6b155c8aaC74004732A621B64bC669bb79',
     waArbWETH: '0x854B004700885A61107B458f11eCC169A019b764',
+    USDS: '0x2f47a6D6115AF4fC1935f5C9079C8aCBA92E5aB4',
+    sUSDS: '0x999F26D47B916340E62A6bb924708A5007eb80Cb',
   },
   [Network.OPTIMISM]: {
     ETH: '0xF6D4E5a7c5215F91f59a95065190CCa24bf64554',
@@ -2191,9 +2205,10 @@ export const Holders: {
     waBasWETH: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
     wstETH: '0x96892b8FBd24e0aC40BD98A304095a6c485A6A68',
     waBaswstETH: '0x854B004700885A61107B458f11eCC169A019b764',
-    sUSDS: '0xC9716E991396AA933Fa7A481003a5953bcBabC17',
     smUSDC: '0x88457F47c9BEC8379eB90d8dC3592F79084e555d',
     waBasGHO: '0x450C01300B83bE379113256038b4Dd3b45d23B5e',
+    USDS: '0x87549A7DF7a002f756118EB19b59C2317E227017',
+    sUSDS: '0xC9716E991396AA933Fa7A481003a5953bcBabC17',
   },
   [Network.SEPOLIA]: {
     bal: '0xDb4ff41B4C1222c2b1869A67Be115070688989a2',