@paraswap/dex-lib 3.8.15 → 3.8.16-oswap.1

package/src/dex/oswap/oswap.ts

@@ -0,0 +1,392 @@
+import { Interface } from '@ethersproject/abi';
+import { AsyncOrSync } from 'ts-essentials';
+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, getBigIntPow } from '../../utils';
+import { Context, IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { OSwapData, OSwapPool, OSwapPoolState } from './types';
+import {
+  SimpleExchange,
+  getLocalDeadlineAsFriendlyPlaceholder,
+} from '../simple-exchange';
+import { OSwapConfig, Adapters, OSWAP_GAS_COST } from './config';
+import { OSwapEventPool } from './oswap-pool';
+import OSwapABI from '../../abi/oswap/oswap.abi.json';
+import { extractReturnAmountPosition } from '../../executor/utils';
+
+export class OSwap extends SimpleExchange implements IDex<OSwapData> {
+  readonly eventPools: { [id: string]: OSwapEventPool } = {};
+
+  readonly hasConstantPriceLargeAmounts = false;
+
+  // This may change in the future, but currently OSwap does not support native ETH.
+  readonly needWrapNative = true;
+
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(OSwapConfig);
+
+  logger: Logger;
+
+  readonly iOSwap: Interface;
+
+  readonly pools: [OSwapPool];
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    protected adapters = Adapters[network] || {},
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.iOSwap = new Interface(OSwapABI);
+
+    this.pools = OSwapConfig[dexKey][network].pools;
+
+    // Create an OSwapEventPool per pool, to track each pool's state by subscribing to on-chain events.
+    for (const pool of this.pools) {
+      this.eventPools[pool.id] = new OSwapEventPool(
+        dexKey,
+        pool,
+        network,
+        dexHelper,
+        this.logger,
+      );
+    }
+  }
+
+  // Returns the list of contract adapters (name and index)
+  // for a buy/sell. Return null if there are no adapters.
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return null;
+  }
+
+  // Returns the pool matching the specified token pair or null if none found.
+  // Note: OSwap V1 does not support more than 1 pool per pair.
+  getPoolByTokenPair(srcToken: Token, destToken: Token): OSwapPool | null {
+    const srcAddress = srcToken.address.toLowerCase();
+    const destAddress = destToken.address.toLowerCase();
+
+    // A pair must have 2 different tokens.
+    if (srcAddress === destAddress) return null;
+
+    for (const pool of this.pools) {
+      if (
+        (srcAddress === pool.token0 && destAddress === pool.token1) ||
+        (srcAddress === pool.token1 && destAddress === pool.token0)
+      ) {
+        return pool;
+      }
+    }
+    return null;
+  }
+
+  getPoolById(id: string): OSwapPool | null {
+    for (const pool of this.pools) {
+      if (pool.id === id) return pool;
+    }
+    return null;
+  }
+
+  // Returns a list of pool using the token.
+  getPoolsByTokenAddress(tokenAddress: Address): OSwapPool[] {
+    const address = tokenAddress.toLowerCase();
+    let pools: OSwapPool[] = [];
+    for (const pool of this.pools) {
+      if (address === pool.token0 || address === pool.token1) {
+        pools.push(pool);
+      }
+    }
+    return pools;
+  }
+
+  // Returns the list of pool identifiers that can be used
+  // for a given swap. poolIdentifiers must be unique
+  // across DEXes. It is recommended to use
+  // ${dexKey}_${poolAddress} as a poolIdentifier
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    const pool = this.getPoolByTokenPair(srcToken, destToken);
+    return pool ? [pool.id] : [];
+  }
+
+  // Sell: Given "amount" of "from" token, how much of "to" token will be received by the trader.
+  // Buy: Given "amount" of "dest" token, how much of "to" token is required from the trader.
+  // Note: OSwap traderate is at precision 36.
+  calcPrice(
+    pool: OSwapPool,
+    state: OSwapPoolState,
+    from: Token,
+    amount: bigint,
+    side: SwapSide,
+    checkLiquidity = true,
+  ): bigint {
+    const rate =
+      from.address.toLowerCase() === pool.token0
+        ? BigInt(state.traderate0)
+        : BigInt(state.traderate1);
+
+    const price =
+      side === SwapSide.SELL
+        ? (amount * rate) / getBigIntPow(36)
+        : (amount * getBigIntPow(36)) / rate;
+
+    if (
+      checkLiquidity &&
+      !this.hasEnoughLiquidity(pool, state, from, amount, price, side)
+    ) {
+      throw new Error('Not enough liquidity');
+    }
+
+    return price;
+  }
+
+  // Returns true if the pool has enough liquidity for the swap. False otherwise.
+  hasEnoughLiquidity(
+    pool: OSwapPool,
+    state: OSwapPoolState,
+    from: Token,
+    amount: bigint,
+    needed: bigint,
+    side: SwapSide,
+  ): boolean {
+    if (side === SwapSide.SELL) {
+      return from.address.toLowerCase() === pool.token0
+        ? needed <= BigInt(state.balance1)
+        : needed <= BigInt(state.balance0);
+    }
+    // SwapSide.BUY
+    return from.address.toLowerCase() === pool.token0
+      ? amount <= BigInt(state.balance1)
+      : amount <= BigInt(state.balance0);
+  }
+
+  // Returns pool prices for amounts.
+  // If limitPools is defined only pools in limitPools
+  // should be used. If limitPools is undefined then
+  // any pool can be used.
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<OSwapData>> {
+    try {
+      // Get the pool to use.
+      const pool = this.getPoolByTokenPair(srcToken, destToken);
+      if (!pool) return null;
+
+      // Make sure the pool meets the optional limitPools filter.
+      if (limitPools && !limitPools.includes(pool.id)) return null;
+
+      const eventPool = this.eventPools[pool.id];
+
+      if (!eventPool) {
+        this.logger.error(`OSwap pool ${pool.id}: No EventPool found.`);
+
+        return null;
+      }
+
+      const state = await eventPool.getStateOrGenerate(blockNumber);
+
+      // Calculate the prices
+      const unitAmount = getBigIntPow(18);
+      const unitPrice = this.calcPrice(
+        pool,
+        state,
+        srcToken,
+        unitAmount,
+        side,
+        false,
+      );
+      const prices = amounts.map(amount =>
+        this.calcPrice(pool, state, srcToken, amount, side),
+      );
+
+      return [
+        {
+          prices,
+          unit: unitPrice,
+          data: {
+            pool: pool.address,
+            path: [srcToken.address, destToken.address],
+          },
+          exchange: this.dexKey,
+          poolIdentifier: pool.id,
+          gasCost: OSWAP_GAS_COST,
+          poolAddresses: [pool.address],
+        },
+      ];
+    } catch (e) {
+      this.logger.error(
+        `Error_getPricesVolume ${srcToken.address || srcToken.symbol}, ${
+          destToken.address || destToken.symbol
+        }, ${side}:`,
+        e,
+      );
+
+      return null;
+    }
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(poolPrices: PoolPrices<OSwapData>): number | number[] {
+    return (
+      CALLDATA_GAS_COST.DEX_OVERHEAD +
+      // ParentStruct header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> path[] header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> path length
+      CALLDATA_GAS_COST.LENGTH_SMALL +
+      // ParentStruct -> path[0]
+      CALLDATA_GAS_COST.ADDRESS +
+      // ParentStruct -> path[1]
+      CALLDATA_GAS_COST.ADDRESS +
+      // ParentStruct -> receiver header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> receiver
+      CALLDATA_GAS_COST.ADDRESS
+    );
+  }
+
+  // Encode params required by the exchange adapter
+  // Used for multiSwap, buy & megaSwap
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OSwapData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: data.pool,
+      payload: '',
+      networkFee: '0',
+    };
+  }
+
+  // Encode call data used by simpleSwap like routers
+  // Used for simpleSwap & simpleBuy
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: OSwapData,
+    side: SwapSide,
+    _: Context,
+    executorAddress: Address,
+  ): DexExchangeParam {
+    let method: string;
+    let args: any;
+    let returnAmountPos: number | undefined = undefined;
+
+    const deadline = getLocalDeadlineAsFriendlyPlaceholder();
+    if (side === SwapSide.SELL) {
+      method = 'swapExactTokensForTokens';
+      returnAmountPos = extractReturnAmountPosition(
+        this.iOSwap,
+        method,
+        'amounts',
+        1,
+      );
+      args = [srcAmount, destAmount, data.path, recipient, deadline];
+    } else {
+      method = 'swapTokensForExactTokens';
+      args = [destAmount, srcAmount, data.path, recipient, deadline];
+    }
+
+    const swapData = this.iOSwap.encodeFunctionData(method, args);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.pool,
+      returnAmountPos,
+    };
+  }
+
+  // This is called once before getTopPoolsForToken is
+  // called for multiple tokens. This can be helpful to
+  // update common state required for calculating
+  // getTopPoolsForToken. It is optional for a DEX
+  // to implement this
+  async updatePoolState(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  // Returns a list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    // Get the list of pools using the token.
+    const pools = this.getPoolsByTokenAddress(tokenAddress);
+    if (!pools.length) return [];
+
+    const results = await Promise.all<PoolLiquidity>(
+      pools.map(async pool => {
+        // Get the pool's balance and its USD value.
+        const eventPool = this.eventPools[pool.id];
+        const blockNumber =
+          await this.dexHelper.web3Provider.eth.getBlockNumber();
+        const state = await eventPool.getStateOrGenerate(blockNumber);
+
+        const usd0 = await this.dexHelper.getTokenUSDPrice(
+          { address: pool.token0, decimals: 18 },
+          BigInt(state.balance0),
+        );
+        const usd1 = await this.dexHelper.getTokenUSDPrice(
+          { address: pool.token1, decimals: 18 },
+          BigInt(state.balance1),
+        );
+
+        // Get the other token in the pair.
+        const pairedToken =
+          pool.token0 === tokenAddress.toLowerCase()
+            ? { address: pool.token1, decimals: 18 }
+            : { address: pool.token0, decimals: 18 };
+
+        return {
+          exchange: this.dexKey,
+          address: pool.address,
+          connectorTokens: [pairedToken],
+          liquidityUSD: usd0 + usd1,
+        };
+      }),
+    );
+    return results
+      .filter(r => r)
+      .sort((a, b) => a.liquidityUSD - b.liquidityUSD)
+      .slice(0, limit);
+  }
+
+  // This is optional function in case if your implementation has acquired any resources
+  // you need to release for graceful shutdown. For example, it may be any interval timer
+  releaseResources(): AsyncOrSync<void> {}
+}

package/src/dex/oswap/types.ts

@@ -0,0 +1,29 @@
+import { Address } from '../../types';
+
+// OSwapPoolState is the state of the event subscriber. It is the minimum
+// set of parameters required to compute pool prices.
+export type OSwapPoolState = {
+  traderate0: string;
+  traderate1: string;
+  balance0: string;
+  balance1: string;
+};
+
+// OSwapPoolState is the state of the event subscriber. It is the minimum
+// set of parameters required to compute pool prices.
+export type OSwapData = {
+  pool: Address;
+  path: Address[];
+};
+
+// Each pool has a contract address and token pairs.
+export type OSwapPool = {
+  id: string;
+  address: Address;
+  token0: Address;
+  token1: Address;
+};
+
+export type DexParams = {
+  pools: [OSwapPool];
+};

package/src/dex/solidly-v3/solidly-v3.ts

@@ -49,6 +49,7 @@ import { Contract } from 'web3-eth-contract';
 import { AbiItem } from 'web3-utils';
 import { TickMath } from './contract-math/TickMath';
 import { OnPoolCreatedCallback, SolidlyV3Factory } from './solidly-v3-factory';
+import { SpecialDex } from '../../executor/types';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -727,6 +728,12 @@ export class SolidlyV3
       exchangeData: swapData,
       targetExchange: data.poolAddress,
       returnAmountPos: undefined,
+      ...(side === SwapSide.BUY
+        ? {
+            specialDexSupportsInsertFromAmount: true,
+            specialDexFlag: SpecialDex.BUY_ON_SOLIDLY_V3,
+          }
+        : {}),
     };
   }
 

package/src/dex/trader-joe-v2.1/base.ts

@@ -0,0 +1,167 @@
+import { SwapSide } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { IDexHelper } from '../../dex-helper';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from '../simple-exchange';
+import { NumberAsString } from '@paraswap/core';
+import { AsyncOrSync } from 'ts-essentials';
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import TraderJoeV21RouterABI from '../../abi/TraderJoeV21Router.json';
+import {
+  TraderJoeV2Data,
+  TraderJoeV2RouterFunctions,
+  TraderJoeV2RouterParam,
+} from './types';
+import { extractReturnAmountPosition } from '../../executor/utils';
+
+export class BaseTraderJoeV2
+  extends SimpleExchange
+  implements IDexTxBuilder<TraderJoeV2Data, TraderJoeV2RouterParam>
+{
+  exchangeRouterInterface: Interface;
+
+  constructor(
+    dexHelper: IDexHelper,
+    dexKey: string,
+    protected routerAddress: string,
+    protected versionIndex: string,
+  ) {
+    super(dexHelper, dexKey);
+
+    this.exchangeRouterInterface = new Interface(
+      TraderJoeV21RouterABI as JsonFragment[],
+    );
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    let payload = this.abiCoder.encodeParameters(
+      ['tuple(tuple(uint256[],uint8[],address[]),uint256)'],
+      [
+        [
+          [data.binSteps, data.versions, data.tokenPath],
+          getLocalDeadlineAsFriendlyPlaceholder(), // _deadline: uint256
+        ],
+      ],
+    );
+
+    return {
+      targetExchange: this.routerAddress,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  getSimpleParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): AsyncOrSync<SimpleExchangeParam> {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? TraderJoeV2RouterFunctions.swapExactTokensForTokens
+        : TraderJoeV2RouterFunctions.swapTokensForExactTokens;
+
+    const swapFunctionParams: TraderJoeV2RouterParam =
+      side === SwapSide.SELL
+        ? [
+            srcAmount,
+            destAmount,
+            [data.binSteps, data.versions, data.tokenPath],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ]
+        : [
+            destAmount,
+            srcAmount,
+            [data.binSteps, data.versions, data.tokenPath],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ];
+
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      this.routerAddress,
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? TraderJoeV2RouterFunctions.swapExactTokensForTokens
+        : TraderJoeV2RouterFunctions.swapTokensForExactTokens;
+
+    const placeholder = getLocalDeadlineAsFriendlyPlaceholder();
+
+    const swapFunctionParams: TraderJoeV2RouterParam =
+      side === SwapSide.SELL
+        ? [
+            srcAmount,
+            destAmount,
+            [data.binSteps, data.versions, data.tokenPath],
+            recipient,
+            placeholder,
+          ]
+        : [
+            destAmount,
+            srcAmount,
+            [data.binSteps, data.versions, data.tokenPath],
+            recipient,
+            placeholder,
+          ];
+
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.routerAddress,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              swapFunction,
+              'amountOut',
+            )
+          : undefined,
+    };
+  }
+}

package/src/dex/trader-joe-v2.1/config.ts

@@ -2,8 +2,13 @@ import { Address } from '@paraswap/core';
 import { Network } from '../../constants';
 
 export const TRADERJOE_V2_1_ROUTER_ADDRESS: { [network: number]: Address } = {
-  [Network.AVALANCHE]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
-  [Network.ARBITRUM]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
+  [Network.AVALANCHE]: '0x18556da13313f3532c54711497a8fedac273220e',
+  [Network.ARBITRUM]: '0x18556da13313f3532c54711497a8fedac273220e',
   [Network.BSC]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
   [Network.MAINNET]: '0x9A93a421b74F1c5755b83dD2C211614dC419C44b',
 };
+
+export const TRADERJOE_V2_2_ROUTER_ADDRESS: { [network: number]: Address } = {
+  [Network.AVALANCHE]: '0x18556da13313f3532c54711497a8fedac273220e',
+  [Network.ARBITRUM]: '0x18556da13313f3532c54711497a8fedac273220e',
+};