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

package/src/dex/spark/spark.ts

@@ -0,0 +1,284 @@
+import { SimpleExchange } from '../simple-exchange';
+import { Context, IDex } from '../idex';
+import { SparkParams, SparkData, SparkSDaiFunctions } from './types';
+import { Network, SwapSide } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { Adapters, SDaiConfig } from './config';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  ExchangePrices,
+  Logger,
+  NumberAsString,
+  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 { 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';
+
+export class Spark
+  extends SimpleExchange
+  implements IDex<SparkData, SparkParams>
+{
+  readonly hasConstantPriceLargeAmounts = true;
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(SDaiConfig);
+
+  public readonly eventPool: SparkSDaiEventPool;
+  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 SparkSDaiEventPool(
+      this.dexKey,
+      `${this.daiAddress}_${this.sdaiAddress}`,
+      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<SparkData>> {
+    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<SparkData>): 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: SparkData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const isSell = side === SwapSide.SELL;
+    const { exchange } = data;
+
+    let swapData: string;
+    if (this.isDai(srcToken)) {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SparkSDaiFunctions.deposit : SparkSDaiFunctions.mint,
+        [isSell ? srcAmount : destAmount, this.augustusAddress],
+      );
+    } else {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SparkSDaiFunctions.redeem : SparkSDaiFunctions.withdraw,
+        [
+          isSell ? srcAmount : destAmount,
+          this.augustusAddress,
+          this.augustusAddress,
+        ],
+      );
+    }
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SparkData,
+    side: SwapSide,
+    _: Context,
+    executorAddress: Address,
+  ): DexExchangeParam {
+    const isSell = side === SwapSide.SELL;
+    const { exchange } = data;
+
+    let swapData: string;
+    if (this.isDai(srcToken)) {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SparkSDaiFunctions.deposit : SparkSDaiFunctions.mint,
+        [isSell ? srcAmount : destAmount, recipient],
+      );
+    } else {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SparkSDaiFunctions.redeem : SparkSDaiFunctions.withdraw,
+        [isSell ? srcAmount : destAmount, recipient, executorAddress],
+      );
+    }
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: exchange,
+      returnAmountPos: isSell
+        ? extractReturnAmountPosition(
+            this.sdaiInterface,
+            this.isDai(srcToken)
+              ? SparkSDaiFunctions.deposit
+              : SparkSDaiFunctions.redeem,
+            this.isDai(srcToken) ? 'shares' : 'assets',
+          )
+        : undefined,
+    };
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: SparkData,
+    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/spark/types.ts

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

package/src/dex/spark/utils.ts

@@ -0,0 +1,47 @@
+import { Contract } from 'web3-eth-contract';
+import { SparkSDaiPoolState } from './types';
+import { Interface, AbiCoder } from '@ethersproject/abi';
+
+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<SparkSDaiPoolState> {
+  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/src/dex/stable-pool/stable-pool.ts

@@ -12,6 +12,7 @@ import { SimpleExchange } from '../simple-exchange';
 import StablePoolABI from '../../abi/StablePool.json';
 import { IDexHelper } from '../../dex-helper';
 import { StablePoolFunctions, StablePoolData, StablePoolParam } from './types';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class StablePool
   extends SimpleExchange
@@ -123,6 +124,13 @@ export class StablePool
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: exchange,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              StablePoolFunctions.swap,
+            )
+          : undefined,
     };
   }
 }

package/src/dex/swaap-v1/swaap-v1.ts

@@ -41,6 +41,7 @@ import {
 import { SwaapV1Pool } from './swaap-v1-pool';
 import PoolABI from '../../abi/swaap-v1/pool.json';
 import { PoolQuotations } from './libraries/PoolQuotations';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
   static readonly poolInterface = new Interface(PoolABI);
@@ -286,6 +287,14 @@ export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: data.pool,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              SwaapV1.poolInterface,
+              functionName,
+              'tokenAmountOut',
+            )
+          : undefined,
     };
   }
 

package/src/dex/swaap-v2/swaap-v2.ts

@@ -476,6 +476,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       exchangeData: callData,
       specialDexFlag: SpecialDex.SWAP_ON_SWAAP_V2_SINGLE,
       targetExchange: router,
+      returnAmountPos: undefined,
     };
   }
 

package/src/dex/swell/config.ts

@@ -3,12 +3,14 @@ import { DexConfigMap } from '../../types';
 
 type DexParams = {
   swETH: string;
+  rswETH: string;
 };
 
 export const SwellConfig: DexConfigMap<DexParams> = {
   Swell: {
     [Network.MAINNET]: {
       swETH: '0xf951E335afb289353dc249e82926178EaC7DEd78',
+      rswETH: '0xFAe103DC9cf190eD75350761e95403b7b8aFa6c0',
     },
   },
 };

package/src/dex/swell/rsweth-pool.ts

@@ -0,0 +1,58 @@
+import { Interface } from '@ethersproject/abi';
+import { IDexHelper } from '../../dex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import { RSWETHPoolState } from './type';
+import { getOnChainStateRswETH } from './utils';
+import { BI_POWS } from '../../bigint-constants';
+
+export class RswethPool extends StatefulEventSubscriber<RSWETHPoolState> {
+  decoder = (log: Log) => this.poolInterface.parseLog(log);
+
+  constructor(
+    parentName: string,
+    protected dexHelper: IDexHelper,
+    private poolAddress: Address,
+    private poolInterface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, 'rsweth', dexHelper, logger);
+    this.addressesSubscribed = [poolAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<RSWETHPoolState>,
+    log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<RSWETHPoolState> | null> {
+    const event = this.decoder(log);
+    if (event.name === 'Reprice')
+      return {
+        rswETHToETHRateFixed: BigInt(event.args.newRswETHToETHRate),
+      };
+
+    return null;
+  }
+
+  async generateState(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<DeepReadonly<RSWETHPoolState>> {
+    const state = await getOnChainStateRswETH(
+      this.dexHelper.multiContract,
+      this.poolAddress,
+      this.poolInterface,
+      blockNumber,
+    );
+
+    return state;
+  }
+
+  getPrice(blockNumber: number, ethAmount: bigint): bigint {
+    const state = this.getState(blockNumber);
+    if (!state) throw new Error('Cannot compute price');
+    const { rswETHToETHRateFixed } = state;
+
+    // calculation in contract are made with UD60x18 precision
+    return (ethAmount * BI_POWS[18]) / rswETHToETHRateFixed;
+  }
+}

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

@@ -17,38 +17,40 @@ describe('Swell', () => {
   );
   const dexKey = 'Swell';
 
-  [
-    // ContractMethod.simpleSwap,
-    // ContractMethod.multiSwap,
-    // ContractMethod.megaSwap,
-    ContractMethod.swapExactAmountIn,
-  ].forEach(contractMethod => {
-    it(`${contractMethod} - ETH -> SWETH`, async () => {
-      await testE2E(
-        tokens.ETH,
-        tokens.SWETH,
-        holders.ETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        contractMethod,
-        network,
-        provider,
-      );
-    });
+  ['SWETH', 'rswETH'].forEach(token => {
+    [
+      // ContractMethod.simpleSwap,
+      // ContractMethod.multiSwap,
+      // ContractMethod.megaSwap,
+      ContractMethod.swapExactAmountIn,
+    ].forEach(contractMethod => {
+      it(`${contractMethod} - ETH -> ${token}`, async () => {
+        await testE2E(
+          tokens.ETH,
+          tokens[token],
+          holders.ETH,
+          '1000000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+        );
+      });
 
-    it(`${contractMethod} - WETH -> SWETH`, async () => {
-      await testE2E(
-        tokens.WETH,
-        tokens.SWETH,
-        holders.WETH,
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        contractMethod,
-        network,
-        provider,
-      );
+      it(`${contractMethod} - WETH -> ${token}`, async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens[token],
+          holders.WETH,
+          '1000000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+        );
+      });
     });
   });
 });