@paraswap/dex-lib 3.8.2 → 3.8.3-integral-dex

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

@@ -0,0 +1,148 @@
+import { Network, SwapSide } from '../constants';
+import { AdapterExchangeParam, Address, 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 TraderJoeV2RouterABI from '../abi/TraderJoeV2Router.json';
+
+const TRADERJOE_V2_ROUTER_ADDRESS: { [network: number]: Address } = {
+  [Network.AVALANCHE]: '0xE3Ffc583dC176575eEA7FD9dF2A7c65F7E23f4C3',
+  [Network.ARBITRUM]: '0x7BFd7192E76D950832c77BB412aaE841049D8D9B',
+  [Network.BSC]: '0xb66A2704a0dabC1660941628BE987B4418f7a9E8',
+};
+
+type TraderJoeV2RouterSellParams = [
+  _amountIn: NumberAsString,
+  _amountOutMin: NumberAsString,
+  _pairBinSteps: NumberAsString[],
+  _tokenPath: Address[],
+  to: Address,
+  _deadline: number,
+];
+
+type TraderJoeV2RouterBuyParams = [
+  _amountOut: NumberAsString,
+  _amountInMax: NumberAsString,
+  _pairBinSteps: NumberAsString[],
+  _tokenPath: Address[],
+  to: Address,
+  _deadline: string,
+];
+
+type TraderJoeV2RouterParam =
+  | TraderJoeV2RouterSellParams
+  | TraderJoeV2RouterBuyParams;
+
+export type TraderJoeV2Data = {
+  tokenIn: string; // redundant
+  tokenOut: string; // redundant
+  binStep: string;
+};
+
+enum TraderJoeV2RouterFunctions {
+  swapExactTokensForTokens = 'swapExactTokensForTokens',
+  swapTokensForExactTokens = 'swapTokensForExactTokens',
+}
+
+export class TraderJoeV2
+  extends SimpleExchange
+  implements IDexTxBuilder<TraderJoeV2Data, TraderJoeV2RouterParam>
+{
+  static dexKeys = ['traderjoev2'];
+  protected routerAddress: string;
+  exchangeRouterInterface: Interface;
+  needWrapNative = true;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'traderjoev2');
+
+    this.routerAddress =
+      TRADERJOE_V2_ROUTER_ADDRESS[dexHelper.config.data.network];
+
+    this.exchangeRouterInterface = new Interface(
+      TraderJoeV2RouterABI as JsonFragment[],
+    );
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          _pairBinSteps: 'uint256[]',
+          _tokenPath: 'address[]',
+          _deadline: 'uint256',
+        },
+      },
+      {
+        _pairBinSteps: [data.binStep],
+        _tokenPath: [data.tokenIn, data.tokenOut], // FIXME: redundant, shoot & read from contract
+        _deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
+      },
+    );
+
+    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.binStep],
+            [srcToken, destToken],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ]
+        : [
+            destAmount,
+            srcAmount,
+            [data.binStep],
+            [srcToken, destToken],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      this.routerAddress,
+    );
+  }
+}

package/src/dex/uniswap-v3/contract-math/Oracle.ts

@@ -23,7 +23,7 @@ export class Oracle {
   ): OracleObservation {
     const delta = blockTimestamp - last.blockTimestamp;
     return {
-      blockTimestamp: state.blockTimestamp,
+      blockTimestamp,
       tickCumulative: last.tickCumulative + BigInt.asIntN(56, tick) * delta,
       secondsPerLiquidityCumulativeX128:
         last.secondsPerLiquidityCumulativeX128 +
@@ -93,12 +93,12 @@ export class Oracle {
     let beforeOrAt;
     let atOrAfter;
     while (true) {
-      i = (l + r) / 2;
+      i = Math.floor((l + r) / 2);
 
       beforeOrAt = state.observations[i % cardinality];
 
       // we've landed on an uninitialized tick, keep searching higher (more recently)
-      if (!beforeOrAt.initialized) {
+      if (!beforeOrAt || !beforeOrAt.initialized) {
         l = i + 1;
         continue;
       }
@@ -150,7 +150,8 @@ export class Oracle {
     }
 
     beforeOrAt = state.observations[(index + 1) % cardinality];
-    if (!beforeOrAt.initialized) beforeOrAt = state.observations[0];
+    if (!beforeOrAt || !beforeOrAt.initialized)
+      beforeOrAt = state.observations[0];
 
     _require(
       Oracle.lte(time, beforeOrAt.blockTimestamp, target),

package/src/dex/zerox/config.ts

@@ -0,0 +1,31 @@
+import { Network } from '../../constants';
+
+export const ZRX_EXCHANGE: Record<number, Record<number, string>> = {
+  [Network.MAINNET]: {
+    2: '0x080bf510fcbf18b91105470639e9561022937712',
+    3: '0x61935CbDd02287B511119DDb11Aeb42F1593b7Ef',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.BSC]: {
+    2: '0x3F93C3D9304a70c9104642AB8cD37b1E2a7c203A',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.POLYGON]: {
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+};
+
+export const ZRX_EXCHANGE_ERC20PROXY: Record<number, Record<number, string>> = {
+  [Network.MAINNET]: {
+    1: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
+    2: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.BSC]: {
+    2: '0xCF21d4b7a265FF779accBA55Ace0F56C8cE6e379',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.POLYGON]: {
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+};

package/src/dex/zerox/index.ts

@@ -0,0 +1,328 @@
+import { AbiEncoder } from '@0x/utils';
+import { Interface } from '@ethersproject/abi';
+
+import IParaswapAbi from '../../abi/IParaswap.json';
+import ZRX_V2_ABI from '../../abi/zrx.v2.json';
+import ZRX_V3_ABI from '../../abi/zrx.v3.json';
+import ZRX_V4_ABI from '../../abi/zrx.v4.json';
+
+import { SwapSide } from '../../constants';
+import { SimpleExchange } from '../simple-exchange';
+import { ZeroXOrder } from './order';
+
+import type { IDexTxBuilder } from '../idex';
+import type {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+  TxInfo,
+} from '../../types';
+import {
+  ZeroXFunctions,
+  type ZeroXData,
+  type ZeroXParam,
+  type ZeroXSignedOrderV2,
+  type ZeroXSignedOrderV4,
+} from './types';
+import { IDexHelper } from '../../dex-helper';
+import { ZRX_EXCHANGE, ZRX_EXCHANGE_ERC20PROXY } from './config';
+
+const ZRX_ABI: any = {
+  2: ZRX_V2_ABI,
+  3: ZRX_V3_ABI,
+  4: ZRX_V4_ABI,
+};
+
+export class ZeroX
+  extends SimpleExchange
+  implements IDexTxBuilder<ZeroXData, ZeroXParam>
+{
+  static dexKeys = ['zerox'];
+  routerInterface: Interface;
+  needWrapNative = true;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'zerox');
+    this.routerInterface = new Interface(IParaswapAbi);
+  }
+
+  private getExchange(data: ZeroXData) {
+    return ZRX_EXCHANGE[this.network][data.version];
+  }
+
+  protected buildSimpleSwapData(data: ZeroXData, srcAmount: NumberAsString) {
+    const zrxABI = ZRX_ABI[data.version];
+    const signature = data.order.signature;
+    const order = ZeroXOrder.formatOrders(data.order, data.version);
+
+    const methodAbi = zrxABI.find(
+      (m: any) =>
+        m.name ===
+        (data.version === 4 ? 'fillRfqOrder' : 'marketSellOrdersNoThrow'),
+    );
+
+    const abiEncoder = new AbiEncoder.Method(methodAbi);
+    // TODO: fillLimitOrder only accepts one order, find something that can accept multiple orders
+    return abiEncoder.encode(
+      data.version === 4
+        ? [order, signature, srcAmount]
+        : [[order], srcAmount, [signature]],
+    );
+  }
+
+  protected buildPayload(data: ZeroXData) {
+    const payload =
+      data.version === 4
+        ? this.abiCoder.encodeParameter(
+            {
+              ParentStruct: {
+                order: {
+                  makerToken: 'address',
+                  takerToken: 'address',
+                  makerAmount: 'uint128',
+                  takerAmount: 'uint128',
+                  maker: 'address',
+                  taker: 'address',
+                  txOrigin: 'address',
+                  pool: 'bytes32',
+                  expiry: 'uint64',
+                  salt: 'uint256',
+                },
+                signature: {
+                  signatureType: 'uint8',
+                  v: 'uint8',
+                  r: 'bytes32',
+                  s: 'bytes32',
+                },
+              },
+            },
+            {
+              order: ZeroXOrder.formatOrders(data.order, 4),
+              signature: data.order.signature,
+            },
+          )
+        : this.abiCoder.encodeParameter(
+            {
+              ParentStruct: {
+                'orders[]': {
+                  makerAddress: 'address', // Address that created the order.
+                  takerAddress: 'address', // Address that is allowed to fill the order. If set to 0, any address is allowed to fill the order.
+                  feeRecipientAddress: 'address', // Address that will receive fees when order is filled.
+                  senderAddress: 'address', // Address that is allowed to call Exchange contract methods that affect this order. If set to 0, any address is allowed to call these methods.
+                  makerAssetAmount: 'uint256', // Amount of makerAsset being offered by maker. Must be greater than 0.
+                  takerAssetAmount: 'uint256', // Amount of takerAsset being bid on by maker. Must be greater than 0.
+                  makerFee: 'uint256', // Fee paid to feeRecipient by maker when order is filled.
+                  takerFee: 'uint256', // Fee paid to feeRecipient by taker when order is filled.
+                  expirationTimeSeconds: 'uint256', // Timestamp in seconds at which order expires.
+                  salt: 'uint256', // Arbitrary number to facilitate uniqueness of the order's hash.
+                  makerAssetData: 'bytes', // Encoded data that can be decoded by a specified proxy contract when transferring makerAsset. The leading bytes4 references the id of the asset proxy.
+                  takerAssetData: 'bytes',
+                },
+                signatures: 'bytes[]',
+              },
+            },
+            {
+              orders: [ZeroXOrder.formatOrders(data.order, 2)],
+              signatures: [data.order.signature],
+            },
+          );
+    return payload;
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    toAmount: NumberAsString, // required for buy case
+    data: ZeroXData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: this.getExchange(data),
+      payload: this.buildPayload(data),
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    src: Address,
+    dest: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: ZeroXData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    if (side === SwapSide.BUY) {
+      // Adjust the srcAmount according to the exact order price (rounding up)
+      if (data.version === 4) {
+        const order = data.order as ZeroXSignedOrderV4;
+        if (BigInt(destAmount) > BigInt(order.makerAmount)) {
+          throw new Error(
+            `ZeroX destAmount ${destAmount} > makerAmount ${order.makerAmount}`,
+          );
+        }
+        const calc =
+          (BigInt(destAmount) * BigInt(order.takerAmount) +
+            BigInt(order.makerAmount) -
+            1n) /
+          BigInt(order.makerAmount);
+        if (calc > BigInt(srcAmount)) {
+          throw new Error(`ZeroX calc ${calc} > srcAmount ${srcAmount}`);
+        }
+        srcAmount = calc.toString();
+      } else {
+        const order = data.order as ZeroXSignedOrderV2;
+        if (BigInt(destAmount) > BigInt(order.makerAssetAmount)) {
+          throw new Error(
+            `ZeroX destAmount ${destAmount} > makerAmount ${order.makerAssetAmount}`,
+          );
+        }
+        const calc =
+          (BigInt(destAmount) * BigInt(order.takerAssetAmount) +
+            BigInt(order.makerAssetAmount) -
+            1n) /
+          BigInt(order.makerAssetAmount);
+        if (calc > BigInt(srcAmount)) {
+          throw new Error(`ZeroX calc ${calc} > srcAmount ${srcAmount}`);
+        }
+        srcAmount = calc.toString();
+      }
+    }
+    const swapData = this.buildSimpleSwapData(data, srcAmount);
+    const networkFees = '0';
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      src,
+      srcAmount,
+      dest,
+      destAmount,
+      swapData,
+      this.getExchange(data),
+      ZRX_EXCHANGE_ERC20PROXY[this.network][data.version],
+      networkFees,
+    );
+  }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    _recipient: Address,
+    data: ZeroXData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) {
+      // Adjust the srcAmount according to the exact order price (rounding up)
+      if (data.version === 4) {
+        const order = data.order as ZeroXSignedOrderV4;
+        if (BigInt(destAmount) > BigInt(order.makerAmount)) {
+          throw new Error(
+            `ZeroX destAmount ${destAmount} > makerAmount ${order.makerAmount}`,
+          );
+        }
+        const calc =
+          (BigInt(destAmount) * BigInt(order.takerAmount) +
+            BigInt(order.makerAmount) -
+            1n) /
+          BigInt(order.makerAmount);
+        if (calc > BigInt(srcAmount)) {
+          throw new Error(`ZeroX calc ${calc} > srcAmount ${srcAmount}`);
+        }
+        srcAmount = calc.toString();
+      } else {
+        const order = data.order as ZeroXSignedOrderV2;
+        if (BigInt(destAmount) > BigInt(order.makerAssetAmount)) {
+          throw new Error(
+            `ZeroX destAmount ${destAmount} > makerAmount ${order.makerAssetAmount}`,
+          );
+        }
+        const calc =
+          (BigInt(destAmount) * BigInt(order.takerAssetAmount) +
+            BigInt(order.makerAssetAmount) -
+            1n) /
+          BigInt(order.makerAssetAmount);
+        if (calc > BigInt(srcAmount)) {
+          throw new Error(`ZeroX calc ${calc} > srcAmount ${srcAmount}`);
+        }
+        srcAmount = calc.toString();
+      }
+    }
+    const swapData = this.buildSimpleSwapData(data, srcAmount);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: this.getExchange(data),
+      returnAmountPos: undefined,
+    };
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: ZeroXData,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod: string,
+  ): TxInfo<ZeroXParam> {
+    const usePermit = permit !== '0x';
+    const encoder = (...params: ZeroXParam) => {
+      switch (data.version) {
+        case 2:
+          return this.routerInterface.encodeFunctionData(
+            usePermit
+              ? ZeroXFunctions.swapOnZeroXv2WithPermit
+              : ZeroXFunctions.swapOnZeroXv2,
+            params,
+          );
+        case 4:
+          return this.routerInterface.encodeFunctionData(
+            usePermit
+              ? ZeroXFunctions.swapOnZeroXv4WithPermit
+              : ZeroXFunctions.swapOnZeroXv4,
+            params,
+          );
+        default:
+          throw new Error(`ZeroX version ${data.version} is not supported!`);
+      }
+    };
+    return {
+      params: usePermit
+        ? [
+            srcToken,
+            destToken,
+            srcAmount,
+            destAmount,
+            this.getExchange(data),
+            this.buildPayload(data),
+            permit,
+          ]
+        : [
+            srcToken,
+            destToken,
+            srcAmount,
+            destAmount,
+            this.getExchange(data),
+            this.buildPayload(data),
+          ],
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [ZeroXFunctions.swapOnZeroXv2, ZeroXFunctions.swapOnZeroXv4];
+  }
+}

package/src/dex/zerox/order.ts

@@ -0,0 +1,62 @@
+import {
+  ZeroXSignedOrder,
+  ZeroXSignedOrderV2,
+  ZeroXSignedOrderV4,
+} from './types';
+
+export class ZeroXOrder {
+  static formatOrderV4(order: ZeroXSignedOrderV4, version: number) {
+    return {
+      makerToken: order.makerToken,
+      takerToken: order.takerToken,
+      makerAmount: order.makerAmount,
+      takerAmount: order.takerAmount,
+      maker: order.maker,
+      taker: order.taker,
+      txOrigin: order.txOrigin,
+      pool: order.pool,
+      expiry: order.expiry,
+      salt: order.salt,
+    };
+  }
+
+  static formatOrderV23(order: ZeroXSignedOrderV2, version: number) {
+    const feeAssetData =
+      version === 3
+        ? {
+            makerFeeAssetData: order.makerFeeAssetData,
+            takerFeeAssetData: order.takerFeeAssetData,
+          }
+        : {};
+
+    return {
+      makerAddress: order.makerAddress,
+      takerAddress: order.takerAddress,
+      feeRecipientAddress: order.feeRecipientAddress,
+      senderAddress: order.senderAddress,
+      makerAssetAmount: order.makerAssetAmount,
+      takerAssetAmount: order.takerAssetAmount,
+      makerFee: order.makerFee,
+      takerFee: order.takerFee,
+      expirationTimeSeconds: order.expirationTimeSeconds,
+      salt: order.salt,
+      makerAssetData: order.makerAssetData,
+      takerAssetData: order.takerAssetData,
+      ...feeAssetData,
+    };
+  }
+
+  static formatOrders(order: ZeroXSignedOrder, version: number = 2) {
+    if (isV4Order(order, version)) {
+      return ZeroXOrder.formatOrderV4(order, version);
+    }
+    return ZeroXOrder.formatOrderV23(order, version);
+  }
+}
+
+function isV4Order(
+  order: ZeroXSignedOrder,
+  version: number = 2,
+): order is ZeroXSignedOrderV4 {
+  return version === 4;
+}

package/src/dex/zerox/types.ts

@@ -0,0 +1,82 @@
+import { Address } from '@paraswap/sdk';
+import { NumberAsString } from '../../types';
+
+export enum OrderStatus {
+  INVALID, // Default value
+  INVALID_MAKER_ASSET_AMOUNT, // Order does not have a valid maker asset amount
+  INVALID_TAKER_ASSET_AMOUNT, // Order does not have a valid taker asset amount
+  FILLABLE, // Order is fillable
+  EXPIRED, // Order has already expired
+  FULLY_FILLED, // Order is fully filled
+  CANCELLED, // Order has been cancelled
+}
+
+type Value = NumberAsString | number;
+
+export interface ZeroXSignedOrderV2 {
+  senderAddress: string;
+  makerAddress: string;
+  takerAddress: string;
+  makerFee: Value;
+  takerFee: Value;
+  makerAssetAmount: Value;
+  takerAssetAmount: Value;
+  makerAssetData: string;
+  takerAssetData: string;
+  salt: Value;
+  exchangeAddress: string;
+  feeRecipientAddress: string;
+  expirationTimeSeconds: Value;
+  makerFeeAssetData: string;
+  takerFeeAssetData: string;
+  signature: string;
+}
+
+export interface ZeroXSignedOrderV4 {
+  makerToken: string;
+  takerToken: string;
+  makerAmount: Value;
+  takerAmount: Value;
+  maker: string;
+  taker: string;
+  txOrigin: string;
+  pool: string;
+  expiry: Value;
+  salt: Value;
+  signature: any; // TODO: fix type
+}
+
+export type ZeroXSignedOrder = ZeroXSignedOrderV2 | ZeroXSignedOrderV4;
+
+export enum ZeroXFunctions {
+  swapOnZeroXv2 = 'swapOnZeroXv2',
+  swapOnZeroXv4 = 'swapOnZeroXv4',
+  swapOnZeroXv2WithPermit = 'swapOnZeroXv2WithPermit',
+  swapOnZeroXv4WithPermit = 'swapOnZeroXv4WithPermit',
+}
+
+export type ZeroXData = {
+  version: number;
+  order: ZeroXSignedOrder;
+};
+
+export type SwapOnZeroXParam = [
+  srcToken: Address,
+  destToken: Address,
+  srcAmount: NumberAsString,
+  destAmount: NumberAsString,
+  exchange: Address,
+  payload: string,
+];
+
+export type SwapOnZeroXWithPermitParam = [
+  srcToken: Address,
+  destToken: Address,
+  srcAmount: NumberAsString,
+  destAmount: NumberAsString,
+  exchange: Address,
+  payload: string,
+  permit: string,
+];
+
+export type ZeroXParam = SwapOnZeroXParam | SwapOnZeroXWithPermitParam;