@paraswap/dex-lib 2.43.0 → 2.44.1

package/src/config.ts

@@ -54,6 +54,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       Adapter02: '0xFC2Ba6E830a04C25e207B8214b26d8C713F6881F',
       Adapter03: '0xBAEeb4540f59d30E567a5B563CC0c4587eDd9366',
       Adapter04: '0x369A2FDb910d432f0a07381a5E3d27572c876713',
+      Adapter05: '0x3329dfa55A40B450952FBE0203167Ae6908E656d',
       BuyAdapter: '0x84bEF12C9931cE12662cc9F2366b6a5029E4BD29',
       BuyAdapter02: '0xe53d24CD81cC81bbf271AD7B02D0d67f851D727c',
     },

package/src/dex/index.ts

@@ -1,3 +1,4 @@
+import _ from 'lodash';
 import { UnoptimizedRate } from '../types';
 import { CurveV2 } from './curve-v2';
 import { IDexTxBuilder, DexContructor, IDex, IRouteOptimizer } from './idex';
@@ -83,6 +84,7 @@ import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 import { Dexalot } from './dexalot/dexalot';
 import { Smardex } from './smardex/smardex';
 import { Wombat } from './wombat/wombat';
+import { Swell } from './swell/swell';
 
 const LegacyDexes = [
   CurveV2,
@@ -163,6 +165,7 @@ const Dexes = [
   SolidlyV3,
   Smardex,
   Wombat,
+  Swell,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<
@@ -292,7 +295,7 @@ export class DexAdapterService {
   }
 
   getAllDexKeys() {
-    return this.dexKeys;
+    return _.uniq(this.dexKeys);
   }
 
   getDexByKey(key: string): IDex<any, any, any> {

package/src/dex/simple-exchange.ts

@@ -44,7 +44,7 @@ export class SimpleExchange {
   readonly cacheStateKey: string;
   private readonly cacheApprovesKey: string;
 
-  constructor(dexHelper: IDexHelper, public dexKey: string) {
+  constructor(protected readonly dexHelper: IDexHelper, public dexKey: string) {
     this.simpleSwapHelper = new Interface(SimpleSwapHelperABI);
     this.erc20Interface = new Interface(ERC20ABI);
     this.erc20Contract = new dexHelper.web3Provider.eth.Contract(
@@ -183,4 +183,11 @@ export class SimpleExchange {
       networkFee,
     };
   }
+
+  protected isWETH(tokenAddress: string) {
+    const weth =
+      this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+
+    return tokenAddress.toLowerCase() === weth;
+  }
 }

package/src/dex/solidly/solidly.ts

@@ -67,6 +67,7 @@ export class Solidly extends UniswapV2 {
       _.omit(SolidlyConfig, [
         'Velodrome',
         'VelodromeV2',
+        'Aerodrome',
         'SpiritSwapV2',
         'Cone',
         'SolidlyV2',

package/src/dex/swell/config.ts

@@ -0,0 +1,27 @@
+import { Network, SwapSide } from '../../constants';
+import { DexConfigMap } from '../../types';
+
+type DexParams = {
+  swETH: string;
+};
+
+export const SwellConfig: DexConfigMap<DexParams> = {
+  Swell: {
+    [Network.MAINNET]: {
+      swETH: '0xf951E335afb289353dc249e82926178EaC7DEd78',
+    },
+  },
+};
+
+export const Adapters: {
+  [chainId: number]: { [side: string]: { name: string; index: number }[] };
+} = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'Adapter05',
+        index: 1,
+      },
+    ],
+  },
+};

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

@@ -0,0 +1,53 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+describe('Swell', () => {
+  const network = Network.MAINNET;
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const dexKey = 'Swell';
+
+  [
+    ContractMethod.simpleSwap,
+    ContractMethod.multiSwap,
+    ContractMethod.megaSwap,
+  ].forEach(contractMethod => {
+    it(`${contractMethod} - ETH -> SWETH`, async () => {
+      await testE2E(
+        tokens.ETH,
+        tokens.SWETH,
+        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,
+      );
+    });
+  });
+});

package/src/dex/swell/swell.ts

@@ -0,0 +1,234 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { NumberAsString, SwapSide } from '@paraswap/core';
+import {
+  AdapterExchangeParam,
+  Address,
+  ExchangePrices,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  SimpleExchangeParam,
+  Token,
+  TransferFeeParams,
+} from '../../types';
+import { IDex } from '../idex';
+import SWETH_ABI from '../../abi/swETH.json';
+import { ETHER_ADDRESS, Network } from '../../constants';
+import { IDexHelper } from '../../dex-helper';
+import { SimpleExchange } from '../simple-exchange';
+import { BI_POWS } from '../../bigint-constants';
+import { AsyncOrSync } from 'ts-essentials';
+import { getOnChainState } from './utils';
+import { SwethPool } from './sweth-pool';
+import { getDexKeysWithNetwork, isETHAddress } from '../../utils';
+import { WethFunctions } from '../weth/types';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import _ from 'lodash';
+import { SwellConfig, Adapters } from './config';
+
+export enum swETHFunctions {
+  deposit = 'deposit',
+}
+
+export type SwellData = {};
+export type SwellParams = {};
+
+export class Swell
+  extends SimpleExchange
+  implements IDex<SwellData, SwellParams>
+{
+  static dexKeys = ['Swell'];
+  swETHInterface: Interface;
+  needWrapNative = false;
+  hasConstantPriceLargeAmounts: boolean = true;
+  swETHAddress: string;
+  eventPool: SwethPool;
+  logger: Logger;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SwellConfig, ['Swell']));
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+    protected config = SwellConfig[dexKey][network],
+    protected adapters = Adapters[network],
+  ) {
+    super(dexHelper, 'Swell');
+
+    this.network = dexHelper.config.data.network;
+    this.swETHInterface = new Interface(SWETH_ABI as JsonFragment[]);
+    this.swETHAddress = this.config.swETH.toLowerCase();
+    this.logger = dexHelper.getLogger(this.dexKey);
+    this.eventPool = new SwethPool(
+      this.dexKey,
+      dexHelper,
+      this.swETHAddress,
+      this.swETHInterface,
+      this.logger,
+    );
+  }
+
+  async initializePricing(blockNumber: number) {
+    const poolState = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.swETHAddress,
+      this.swETHInterface,
+      blockNumber,
+    );
+
+    await this.eventPool.initialize(blockNumber, {
+      state: poolState,
+    });
+  }
+
+  getPoolIdentifierKey(): string {
+    return `${ETHER_ADDRESS}_${this.swETHAddress}`.toLowerCase();
+  }
+
+  isEligibleSwap(
+    srcToken: Token | string,
+    destToken: Token | string,
+    side: SwapSide,
+  ): boolean {
+    if (side === SwapSide.BUY) return false;
+
+    const srcTokenAddress = (
+      typeof srcToken === 'string' ? srcToken : srcToken.address
+    ).toLowerCase();
+    const destTokenAddress = (
+      typeof destToken === 'string' ? destToken : destToken.address
+    ).toLowerCase();
+
+    return (
+      (isETHAddress(srcTokenAddress) || this.isWETH(srcTokenAddress)) &&
+      destTokenAddress === this.swETHAddress
+    );
+  }
+
+  assertEligibility(
+    srcToken: Token | string,
+    destToken: Token | string,
+    side: SwapSide,
+  ) {
+    if (!this.isEligibleSwap(srcToken, destToken, side)) {
+      throw new Error('Only eth/weth -> swETH swaps are supported');
+    }
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    return this.isEligibleSwap(srcToken, destToken, side)
+      ? [this.getPoolIdentifierKey()]
+      : [];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amountsIn: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[] | undefined,
+    transferFees?: TransferFeeParams | undefined,
+    isFirstSwap?: boolean | undefined,
+  ): Promise<ExchangePrices<SwellData> | null> {
+    if (!this.isEligibleSwap(srcToken, destToken, side)) return null;
+    if (this.eventPool.getState(blockNumber) === null) return null;
+
+    const unitIn = BI_POWS[18];
+    const unitOut = this.eventPool.getPrice(blockNumber, unitIn);
+    const amountsOut = amountsIn.map(amountIn =>
+      this.eventPool.getPrice(blockNumber, amountIn),
+    );
+
+    return [
+      {
+        prices: amountsOut,
+        unit: unitOut,
+        data: {},
+        exchange: this.dexKey,
+        poolIdentifier: this.getPoolIdentifierKey(),
+        gasCost: 120_000,
+        poolAddresses: [this.swETHAddress],
+      },
+    ];
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: SwellData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    this.assertEligibility(srcToken, destToken, side);
+
+    return {
+      targetExchange: this.swETHAddress, // not used contract side
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: SwellData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    this.assertEligibility(srcToken, destToken, side);
+
+    const callees = [];
+    const calldata = [];
+    const values = [];
+
+    if (this.isWETH(srcToken)) {
+      // note: apparently ERC20 ABI contains wETH fns (deposit() and withdraw())
+      const wethUnwrapData = this.erc20Interface.encodeFunctionData(
+        WethFunctions.withdraw,
+        [srcAmount],
+      );
+      callees.push(this.dexHelper.config.data.wrappedNativeTokenAddress);
+      calldata.push(wethUnwrapData);
+      values.push('0');
+    }
+
+    const swapData = this.swETHInterface.encodeFunctionData(
+      swETHFunctions.deposit,
+      [],
+    );
+
+    callees.push(this.swETHAddress);
+    calldata.push(swapData);
+    values.push(srcAmount);
+
+    return {
+      callees,
+      calldata,
+      values,
+      networkFee: '0',
+    };
+  }
+
+  getCalldataGasCost(poolPrices: PoolPrices<SwellData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_OVERHEAD + CALLDATA_GAS_COST.LENGTH_SMALL;
+  }
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters?.[side] || null;
+  }
+  getTopPoolsForToken(
+    tokenAddress: string,
+    limit: number,
+  ): AsyncOrSync<PoolLiquidity[]> {
+    return [];
+  }
+}

package/src/dex/swell/sweth-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 { SWETHPoolState } from './type';
+import { getOnChainState } from './utils';
+import { BI_POWS } from '../../bigint-constants';
+
+export class SwethPool extends StatefulEventSubscriber<SWETHPoolState> {
+  decoder = (log: Log) => this.poolInterface.parseLog(log);
+
+  constructor(
+    parentName: string,
+    protected dexHelper: IDexHelper,
+    private poolAddress: Address,
+    private poolInterface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, 'sweth', dexHelper, logger);
+    this.addressesSubscribed = [poolAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<SWETHPoolState>,
+    log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<SWETHPoolState> | null> {
+    const event = this.decoder(log);
+    if (event.name === 'Reprice')
+      return {
+        swETHToETHRateFixed: BigInt(event.args.newSwETHToETHRate),
+      };
+
+    return null;
+  }
+
+  async generateState(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<DeepReadonly<SWETHPoolState>> {
+    const state = await getOnChainState(
+      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 { swETHToETHRateFixed } = state;
+
+    // calculation in contract are made with UD60x18 precision
+    return (ethAmount * BI_POWS[18]) / swETHToETHRateFixed;
+  }
+}

package/src/dex/swell/type.ts

@@ -0,0 +1,3 @@
+export type SWETHPoolState = {
+  swETHToETHRateFixed: bigint;
+};

package/src/dex/swell/utils.ts

@@ -0,0 +1,29 @@
+import { Contract } from 'web3-eth-contract';
+import { SWETHPoolState } from './type';
+import { Interface, AbiCoder } from '@ethersproject/abi';
+
+const coder = new AbiCoder();
+
+export async function getOnChainState(
+  multiContract: Contract,
+  poolAddress: string,
+  poolInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SWETHPoolState> {
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate([
+      {
+        target: poolAddress,
+        callData: poolInterface.encodeFunctionData('swETHToETHRate', []),
+      },
+    ])
+    .call({}, blockNumber);
+
+  const decodedData = coder.decode(['uint256'], data.returnData[0]);
+
+  const swETHToETHRateFixed = BigInt(decodedData[0].toString());
+
+  return {
+    swETHToETHRateFixed,
+  };
+}

package/tests/constants-e2e.ts

@@ -23,6 +23,10 @@ export const Tokens: {
       address: ETHER_ADDRESS,
       decimals: 18,
     },
+    SWETH: {
+      address: '0xf951e335afb289353dc249e82926178eac7ded78',
+      decimals: 18,
+    },
     REQ: {
       address: '0x8f8221aFbB33998d8584A2B05749bA73c37a938a',
       decimals: 18,