@paraswap/dex-lib 3.8.33 → 3.8.34-converters

package/src/dex/sky-converter/sky-converter-integration.test.ts

@@ -0,0 +1,135 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { SkyConverter } from './sky-converter';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+
+const network = Network.MAINNET;
+
+const tokenAAmounts = [
+  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],
+];
+
+const tokenBAmounts = [
+  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],
+];
+
+['DaiUsds', 'MkrSky'].forEach(dexKey => {
+  const TokenASymbol = dexKey === 'DaiUsds' ? 'DAI' : 'MKR';
+  const TokenA = Tokens[network][TokenASymbol];
+
+  const TokenBSymbol = dexKey === 'DaiUsds' ? 'USDS' : 'SKY';
+  const TokenB = Tokens[network][TokenBSymbol];
+
+  describe(dexKey, function () {
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const skyConverter = new SkyConverter(network, dexKey, dexHelper);
+
+      const pools = await skyConverter.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.SELL,
+        blocknumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await skyConverter.getPricesVolume(
+        TokenA,
+        TokenB,
+        tokenAAmounts,
+        SwapSide.SELL,
+        blocknumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, tokenAAmounts, SwapSide.SELL, dexKey);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const skyConverter = new SkyConverter(network, dexKey, dexHelper);
+
+      const pools = await skyConverter.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.BUY,
+        blocknumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await skyConverter.getPricesVolume(
+        TokenA,
+        TokenB,
+        tokenBAmounts,
+        SwapSide.BUY,
+        blocknumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, tokenBAmounts, SwapSide.BUY, dexKey);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const skyConverter = new SkyConverter(network, dexKey, dexHelper);
+
+      const poolLiquidity = await skyConverter.getTopPoolsForToken(
+        TokenA.address,
+        10,
+      );
+      console.log(
+        `${TokenASymbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+    });
+  });
+});

package/src/dex/sky-converter/sky-converter.ts

@@ -0,0 +1,222 @@
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  PoolLiquidity,
+  Logger,
+  NumberAsString,
+  DexExchangeParam,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork } from '../../utils';
+import { IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { SkyConverterData } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { SkyConverterConfig } from './config';
+import { BI_POWS } from '../../bigint-constants';
+
+export class SkyConverter
+  extends SimpleExchange
+  implements IDex<SkyConverterData>
+{
+  readonly hasConstantPriceLargeAmounts = true;
+  readonly needWrapNative = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(SkyConverterConfig);
+
+  logger: Logger;
+
+  oldToken: Address;
+  newToken: Address;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    readonly config = SkyConverterConfig[dexKey][network],
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+
+    this.oldToken = this.config.oldTokenAddress.toLowerCase();
+    this.newToken = this.config.newTokenAddress.toLowerCase();
+  }
+
+  async initializePricing(blockNumber: number) {}
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return null;
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if (
+      srcToken.address.toLowerCase() === this.oldToken &&
+      destToken.address.toLowerCase() === this.newToken
+    ) {
+      return [`${this.dexKey}_${destToken.address}`];
+    } else if (
+      srcToken.address.toLowerCase() === this.newToken &&
+      destToken.address.toLowerCase() === this.oldToken
+    ) {
+      return [`${this.dexKey}_${srcToken.address}`];
+    } else {
+      return [];
+    }
+  }
+
+  oldAmountToNewAmount(amount: bigint) {
+    return amount * this.config.newTokenRateMultiplier;
+  }
+
+  newAmountToOldAmount(amount: bigint) {
+    return amount / this.config.newTokenRateMultiplier;
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<SkyConverterData>> {
+    const isKnown =
+      (srcToken.address.toLowerCase() === this.oldToken &&
+        destToken.address.toLowerCase() === this.newToken) ||
+      (srcToken.address.toLowerCase() === this.newToken &&
+        destToken.address.toLowerCase() === this.oldToken);
+
+    if (!isKnown) {
+      return null;
+    }
+
+    const isOldToNew = srcToken.address.toLowerCase() === this.oldToken;
+
+    let mappingFunction: Function;
+
+    if (side === SwapSide.SELL) {
+      if (isOldToNew) {
+        mappingFunction = this.oldAmountToNewAmount.bind(this);
+      } else {
+        mappingFunction = this.newAmountToOldAmount.bind(this);
+      }
+    } else {
+      if (isOldToNew) {
+        mappingFunction = this.newAmountToOldAmount.bind(this);
+      } else {
+        mappingFunction = this.oldAmountToNewAmount.bind(this);
+      }
+    }
+
+    return [
+      {
+        prices: amounts.map(el => mappingFunction(el)),
+        unit: BI_POWS[18],
+        // TODO: Update after simulations
+        gasCost: 40_000,
+        exchange: this.dexKey,
+        poolAddresses: [this.config.converterAddress],
+        data: null,
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(
+    poolPrices: PoolPrices<SkyConverterData>,
+  ): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: SkyConverterData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    // Encode here the payload for adapter
+    const payload = '';
+
+    return {
+      targetExchange: '0x',
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SkyConverterData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapData = this.config.converterIface.encodeFunctionData(
+      srcToken === this.oldToken
+        ? this.config.oldToNewFunctionName
+        : this.config.newToOldFunctionName,
+      [recipient, srcAmount],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.config.converterAddress,
+      returnAmountPos: undefined,
+    };
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (tokenAddress.toLowerCase() === this.oldToken) {
+      return [
+        {
+          exchange: this.dexKey,
+          address: this.config.converterAddress,
+          connectorTokens: [
+            {
+              decimals: 18,
+              address: this.newToken,
+            },
+          ],
+          liquidityUSD: 1000000000, // infinite
+        },
+      ];
+    } else if (tokenAddress.toLowerCase() === this.newToken) {
+      return [
+        {
+          exchange: this.dexKey,
+          address: this.config.converterAddress,
+          connectorTokens: [
+            {
+              decimals: 18,
+              address: this.oldToken,
+            },
+          ],
+          liquidityUSD: 1000000000, // infinite
+        },
+      ];
+    }
+
+    return [];
+  }
+}

package/src/dex/sky-converter/types.ts

@@ -0,0 +1,14 @@
+import { Interface } from '@ethersproject/abi';
+import { Address } from '../../types';
+
+export type SkyConverterData = null;
+
+export type DexParams = {
+  converterAddress: Address;
+  oldTokenAddress: Address;
+  newTokenAddress: Address;
+  newTokenRateMultiplier: bigint;
+  oldToNewFunctionName: string;
+  newToOldFunctionName: string;
+  converterIface: Interface;
+};

package/tests/constants-e2e.ts

@@ -19,6 +19,18 @@ export const Tokens: {
   [network: number]: { [symbol: string]: SmartTokenParams };
 } = {
   [Network.MAINNET]: {
+    USDS: {
+      address: '0xdC035D45d973E3EC169d2276DDab16f1e407384F',
+      decimals: 18,
+    },
+    SKY: {
+      address: '0x56072C95FAA701256059aa122697B133aDEd9279',
+      decimals: 18,
+    },
+    MKR: {
+      address: '0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2',
+      decimals: 18,
+    },
     AA_wstETH: {
       decimals: 18,
       address: '0x2688fc68c4eac90d9e5e1b94776cf14eade8d877',
@@ -1488,6 +1500,9 @@ export const Holders: {
   [network: number]: { [tokenAddress: string]: Address };
 } = {
   [Network.MAINNET]: {
+    USDS: '0xE99d0ba6966c74BF78bF394BD29DCA154c6BC217',
+    SKY: '0x0ddda327A6614130CCb20bc0097313A282176A01',
+    MKR: '0xe9aAA7A9DDc0877626C1779AbC29993aD89A6c1f',
     // Idle tokens
     AA_wstETH: '0xd7C1b48877A7dFA7D51cf1144c89C0A3F134F935',
     'AA_idle_cpPOR-USDC': '0x085c8eaccA6911fE60aE3f8FbAe5F3012E3A05Ec',