@paraswap/dex-lib 2.43.0 → 2.44.0

package/src/config.ts

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

package/src/dex/index.ts

@@ -83,6 +83,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 +164,7 @@ const Dexes = [
   SolidlyV3,
   Smardex,
   Wombat,
+  Swell,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

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/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.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,
+  };
+}